def _create_new_projection_attribute_state_set( proj_ctx: 'ProjectionContext', proj_output_set: 'ProjectionAttributeStateSet', new_res_attr_FK: 'ResolvedAttribute', ref_attr_name: str ) -> 'ProjectionAttributeStateSet': pas_list = ProjectionResolutionCommonUtil._get_leaf_list(proj_ctx, ref_attr_name) source_entity = proj_ctx._projection_directive._original_source_entity_attribute_name if not source_entity: logger.warning(proj_output_set._ctx, CdmOperationReplaceAsForeignKey.__name__, \ CdmOperationReplaceAsForeignKey._create_new_projection_attribute_state_set.__name__, None, CdmLogCode.WARN_PROJ_FK_WITHOUT_SOURCE_ENTITY, ref_attr_name) if pas_list is not None: # update the new foreign key resolved attribute with trait param with reference details reqd_trait = new_res_attr_FK.resolved_traits.find(proj_ctx._projection_directive._res_opt, 'is.linkedEntity.identifier') if reqd_trait and source_entity: trait_param_ent_ref = ProjectionResolutionCommonUtil._create_foreign_key_linked_entity_identifier_trait_parameter(proj_ctx._projection_directive, proj_output_set._ctx.corpus, pas_list) reqd_trait.parameter_values.update_parameter_value(proj_ctx._projection_directive._res_opt, 'entityReferences', trait_param_ent_ref) # Create new output projection attribute state set for FK and add prevPas as previous state set new_proj_attr_state_FK = ProjectionAttributeState(proj_output_set._ctx) new_proj_attr_state_FK._current_resolved_attribute = new_res_attr_FK new_proj_attr_state_FK._previous_state_list = pas_list proj_output_set._add(new_proj_attr_state_FK) else: # Log error & return proj_output_set without any change logger.error(proj_output_set._ctx, CdmOperationReplaceAsForeignKey.__name__, CdmOperationReplaceAsForeignKey._create_new_projection_attribute_state_set.__name__, None, CdmLogCode.ERR_PROJ_REF_ATTR_STATE_FAILURE, ref_attr_name) return proj_output_set
def _append_projection_attribute_state( self, proj_ctx: 'ProjectionContext', proj_output_set: 'ProjectionAttributeStateSet', attr_ctx: 'CdmAttributeContext') -> 'ProjectionAttributeStateSet': # Create a new attribute context for the operation attr_ctx_op_exclude_attrs_param = AttributeContextParameters() attr_ctx_op_exclude_attrs_param._under = attr_ctx attr_ctx_op_exclude_attrs_param._type = CdmAttributeContextType.OPERATION_EXCLUDE_ATTRIBUTES attr_ctx_op_exclude_attrs_param._name = 'operation/index{}/operationExcludeAttributes'.format( self._index) attr_ctx_op_exclude_attrs = CdmAttributeContext._create_child_under( proj_ctx._projection_directive._res_opt, attr_ctx_op_exclude_attrs_param) # Get the top-level attribute names of the attributes to exclude # We use the top-level names because the exclude list may contain a previous name our current resolved attributes had top_level_exclude_attribute_names = ProjectionResolutionCommonUtil._get_top_list( proj_ctx, self.exclude_attributes) # Iterate through all the projection attribute states generated from the source's resolved attributes # Each projection attribute state contains a resolved attribute that it is corresponding to for current_PAS in proj_ctx._current_attribute_state_set._values: # Check if the current projection attribute state's resolved attribute is in the list of attributes to exclude # If this attribute is not in the exclude list, then we are including it in the output if current_PAS._current_resolved_attribute.resolved_name not in top_level_exclude_attribute_names: # Create a new attribute context for the attribute that we are including attr_ctx_added_attr_param = AttributeContextParameters() attr_ctx_added_attr_param._under = attr_ctx attr_ctx_added_attr_param._type = CdmAttributeContextType.ATTRIBUTE_DEFINITION attr_ctx_added_attr_param._name = current_PAS._current_resolved_attribute.resolved_name attr_ctx_added_attr = CdmAttributeContext._create_child_under( proj_ctx._projection_directive._res_opt, attr_ctx_added_attr_param) # Create a projection attribute state for the included attribute # We only create projection attribute states for attributes that are not in the exclude list # Add the current projection attribute state as the previous state of the new projection attribute state new_PAS = ProjectionAttributeState(proj_output_set._ctx) new_PAS._current_resolved_attribute = current_PAS._current_resolved_attribute new_PAS._previous_state_list = [current_PAS] proj_output_set._add(new_PAS) else: # The current projection attribute state's resolved attribute is in the exclude list # Get the attribute name the way it appears in the exclude list # For our attribute context, we want to use the attribute name the attribute has in the exclude list rather than its current name exclude_attribute_name = top_level_exclude_attribute_names[ current_PAS._current_resolved_attribute.resolved_name] # Create a new attribute context for the excluded attribute attr_ctx_excluded_attr_param = AttributeContextParameters() attr_ctx_excluded_attr_param._under = attr_ctx_op_exclude_attrs attr_ctx_excluded_attr_param._type = CdmAttributeContextType.ATTRIBUTE_DEFINITION attr_ctx_excluded_attr_param._name = exclude_attribute_name attr_ctx_excluded_attr = CdmAttributeContext._create_child_under( proj_ctx._projection_directive._res_opt, attr_ctx_excluded_attr_param) return proj_output_set
def _append_projection_attribute_state(self, proj_ctx: 'ProjectionContext', proj_output_set: 'ProjectionAttributeStateSet', attr_ctx: 'CdmAttributeContext') -> 'ProjectionAttributeStateSet': # Create a new attribute context for the operation attr_ctx_op_exclude_attrs_param = AttributeContextParameters() attr_ctx_op_exclude_attrs_param._under = attr_ctx attr_ctx_op_exclude_attrs_param._type = CdmAttributeContextType.OPERATION_EXCLUDE_ATTRIBUTES attr_ctx_op_exclude_attrs_param._name = 'operation/index{}/operationExcludeAttributes'.format(self._index) attr_ctx_op_exclude_attrs = CdmAttributeContext._create_child_under(proj_ctx._projection_directive._res_opt, attr_ctx_op_exclude_attrs_param) # Get the top-level attribute names of the attributes to exclude # We use the top-level names because the exclude list may contain a previous name our current resolved attributes had top_level_exclude_attribute_names = ProjectionResolutionCommonUtil._get_top_list(proj_ctx, self.exclude_attributes) # Initialize a projection attribute context tree builder with the created attribute context for the operation attr_ctx_tree_builder = ProjectionAttributeContextTreeBuilder(attr_ctx_op_exclude_attrs) # Iterate through all the projection attribute states generated from the source's resolved attributes # Each projection attribute state contains a resolved attribute that it is corresponding to for current_PAS in proj_ctx._current_attribute_state_set._states: # Check if the current projection attribute state's resolved attribute is in the list of attributes to exclude # If this attribute is not in the exclude list, then we are including it in the output if current_PAS._current_resolved_attribute.resolved_name not in top_level_exclude_attribute_names: # Create the attribute context parameters and just store it in the builder for now # We will create the attribute contexts at the end attr_ctx_tree_builder._create_and_store_attribute_context_parameters( None, current_PAS, current_PAS._current_resolved_attribute, CdmAttributeContextType.ATTRIBUTE_DEFINITION, current_PAS._current_resolved_attribute.att_ctx, # lineage is the included attribute None) # don't know who will point here yet # Create a projection attribute state for the included attribute by creating a copy of the current state # Copy() sets the current state as the previous state for the new one # We only create projection attribute states for attributes that are not in the exclude list new_PAS = current_PAS._copy() proj_output_set._add(new_PAS) else: # The current projection attribute state's resolved attribute is in the exclude list # Get the attribute name the way it appears in the exclude list exclude_attribute_name = top_level_exclude_attribute_names[current_PAS._current_resolved_attribute.resolved_name] # Create the attribute context parameters and just store it in the builder for now # We will create the attribute contexts at the end attr_ctx_tree_builder._create_and_store_attribute_context_parameters( exclude_attribute_name, current_PAS, current_PAS._current_resolved_attribute, CdmAttributeContextType.ATTRIBUTE_EXCLUDED, current_PAS._current_resolved_attribute.att_ctx, # lineage is the included attribute None) # don't know who will point here yet, excluded, so... this could be the end for you. # Create all the attribute contexts and construct the tree attr_ctx_tree_builder._construct_attribute_context_tree(proj_ctx) return proj_output_set
def _create_new_projection_attribute_state_set( proj_ctx: 'ProjectionContext', proj_output_set: 'ProjectionAttributeStateSet', new_res_attr_FK: 'ResolvedAttribute', ref_attr_name: str) -> 'ProjectionAttributeStateSet': pas_list = ProjectionResolutionCommonUtil._get_leaf_list( proj_ctx, ref_attr_name) if pas_list is not None: # update the new foreign key resolved attribute with trait param with reference details reqd_trait = new_res_attr_FK.resolved_traits.find( proj_ctx._projection_directive._res_opt, 'is.linkedEntity.identifier') if reqd_trait: trait_param_ent_ref = ProjectionResolutionCommonUtil._create_foreign_key_linked_entity_identifier_trait_parameter( proj_ctx._projection_directive, proj_output_set._ctx.corpus, pas_list) reqd_trait.parameter_values.update_parameter_value( proj_ctx._projection_directive._res_opt, 'entityReferences', trait_param_ent_ref) # Create new output projection attribute state set for FK and add prevPas as previous state set new_proj_attr_state_FK = ProjectionAttributeState( proj_output_set._ctx) new_proj_attr_state_FK._current_resolved_attribute = new_res_attr_FK new_proj_attr_state_FK._previous_state_list = pas_list proj_output_set._add(new_proj_attr_state_FK) else: # Log error & return proj_output_set without any change logger.error( CdmOperationReplaceAsForeignKey.__name__, proj_output_set._ctx, 'Unable to locate state for reference attribute \"{}\".'. format(ref_attr_name), CdmOperationReplaceAsForeignKey. _create_new_projection_attribute_state_set.__name__) return proj_output_set
def _append_projection_attribute_state(self, proj_ctx: 'ProjectionContext', proj_attr_state_set: 'ProjectionAttributeStateSet', attr_ctx: 'CdmAttributeContext') -> 'ProjectionAttributeStateSet': # Create a new attribute context for the operation attr_ctx_op_include_attrs_param = AttributeContextParameters() # type: AttributeContextParameters attr_ctx_op_include_attrs_param._under = attr_ctx attr_ctx_op_include_attrs_param._type = CdmAttributeContextType.OPERATION_INCLUDE_ATTRIBUTES attr_ctx_op_include_attrs_param._name = 'operation/indexIndex{}/operationIncludeAttributes'.format(self._index) attr_ctx_op_include_attrs = CdmAttributeContext._create_child_under(proj_ctx._projection_directive._res_opt, attr_ctx_op_include_attrs_param) # type: CdmAttributeContext # Get the top-level attribute names for each of the included attributes # Since the include operation allows providing either current state resolved attribute names # or the previous state resolved attribute names, we search for the name in the PAS tree # and fetch the top level resolved attribute names. top_level_include_attribute_names = ProjectionResolutionCommonUtil._get_top_list(proj_ctx, self.include_attributes) # type: Dict[str, str] # Initialize a projection attribute context tree builder with the created attribute context for the operation attr_ctx_tree_builder = ProjectionAttributeContextTreeBuilder(attr_ctx_op_include_attrs) # Iterate through all the PAS in the PASSet generated from the projection source's resolved attributes for current_PAS in proj_ctx._current_attribute_state_set._states: # Check if the current PASs RA is in the list of attributes to include. if current_PAS._current_resolved_attribute.resolved_name in top_level_include_attribute_names: # Get the attribute name the way it appears in the include list include_attribute_name = top_level_include_attribute_names[current_PAS._current_resolved_attribute.resolved_name] # type: str # Create the attribute context parameters and just store it in the builder for now # We will create the attribute contexts at the end attr_ctx_tree_builder._create_and_store_attribute_context_parameters(include_attribute_name, current_PAS, current_PAS._current_resolved_attribute, CdmAttributeContextType.ATTRIBUTE_DEFINITION) # Create a projection attribute state for the included attribute by creating a copy of the current state # Copy() sets the current state as the previous state for the new one # We only create projection attribute states for attributes in the include list new_PAS = current_PAS._copy() proj_attr_state_set._add(new_PAS) else: # Create the attribute context parameters and just store it in the builder for now # We will create the attribute contexts at the end attr_ctx_tree_builder._create_and_store_attribute_context_parameters(None, current_PAS, current_PAS._current_resolved_attribute, CdmAttributeContextType.ATTRIBUTE_DEFINITION) # Create all the attribute contexts and construct the tree attr_ctx_tree_builder._construct_attribute_context_tree(proj_ctx) return proj_attr_state_set
def _append_projection_attribute_state(self, proj_ctx: 'ProjectionContext', proj_output_set: 'ProjectionAttributeStateSet', \ attr_ctx: 'CdmAttributeContext') -> 'ProjectionAttributeStateSet': # Create a new attribute context for the operation attr_ctx_op_rename_attrs_param = AttributeContextParameters() attr_ctx_op_rename_attrs_param._under = attr_ctx attr_ctx_op_rename_attrs_param._type = CdmAttributeContextType.OPERATION_RENAME_ATTRIBUTES attr_ctx_op_rename_attrs_param._name = 'operation/index{}/operationRenameAttributes'.format( self._index) attr_ctx_op_rename_attrs = CdmAttributeContext._create_child_under( proj_ctx._projection_directive._res_opt, attr_ctx_op_rename_attrs_param) # type: CdmAttributeContext # Get the list of attributes that will be renamed rename_attributes = None # type: List[str] if self.apply_to is not None: rename_attributes = self.apply_to else: rename_attributes = [] for current_PAS in proj_ctx._current_attribute_state_set._states: rename_attributes.append( current_PAS._current_resolved_attribute._resolved_name) # Get the top-level attribute names of the attributes to rename # We use the top-level names because the rename list may contain a previous name our current resolved attributes had top_level_rename_attribute_names = ProjectionResolutionCommonUtil._get_top_list( proj_ctx, rename_attributes) # type: Dict[str, str] source_attribute_name = proj_ctx._projection_directive._original_source_entity_attribute_name # type: str # Initialize a projection attribute context tree builder with the created attribute context for the operation attr_ctx_tree_builder = ProjectionAttributeContextTreeBuilder( attr_ctx_op_rename_attrs) # Iterate through all the projection attribute states generated from the source's resolved attributes # Each projection attribute state contains a resolved attribute that it is corresponding to for current_PAS in proj_ctx._current_attribute_state_set._states: # Check if the current projection attribute state's resolved attribute is in the list of attributes to rename # If this attribute is not in the rename list, then we are including it in the output without changes if current_PAS._current_resolved_attribute.resolved_name in top_level_rename_attribute_names: if isinstance(current_PAS._current_resolved_attribute.target, CdmAttribute): # The current attribute should be renamed new_attribute_name = self._get_new_attribute_name( current_PAS, source_attribute_name) # type: str # Create new resolved attribute with the new name, set the new attribute as target res_attr_new = self._create_new_resolved_attribute( proj_ctx, None, current_PAS._current_resolved_attribute.target, new_attribute_name) # type: ResolvedAttribute # Get the attribute name the way it appears in the applyTo list apply_to_name = top_level_rename_attribute_names[ current_PAS._current_resolved_attribute.resolved_name] # Create the attribute context parameters and just store it in the builder for now # We will create the attribute contexts at the end attr_ctx_tree_builder._create_and_store_attribute_context_parameters( apply_to_name, current_PAS, res_attr_new, CdmAttributeContextType.ATTRIBUTE_DEFINITION, current_PAS._current_resolved_attribute. att_ctx, # lineage is the original attribute None) # don't know who will point here yet # Create a projection attribute state for the renamed attribute by creating a copy of the current state # Copy() sets the current state as the previous state for the new one # We only create projection attribute states for attributes that are in the rename list new_PAS = current_PAS._copy() # Update the resolved attribute to be the new renamed attribute we created new_PAS._current_resolved_attribute = res_attr_new proj_output_set._add(new_PAS) else: logger.warning( self._TAG, self.ctx, 'RenameAttributes is not supported on an attribute group yet.' ) # Add the attribute without changes proj_output_set._add(current_PAS) else: # Pass through proj_output_set._add(current_PAS) # Create all the attribute contexts and construct the tree attr_ctx_tree_builder._construct_attribute_context_tree(proj_ctx) return proj_output_set
def _construct_projection_context( self, proj_directive: 'ProjectionDirective', attr_ctx: 'CdmAttributeContext', ras: Optional['ResolvedAttributeSet'] = None ) -> 'ProjectionContext': """ A function to construct projection context and populate the resolved attribute set that ExtractResolvedAttributes method can then extract This function is the entry point for projection resolution. This function is expected to do the following 3 things: - Create an condition expression tree & default if appropriate - Create and initialize Projection Context - Process operations """ if not attr_ctx: return None proj_context = None # Add projection to context tree acp_proj = AttributeContextParameters() acp_proj._under = attr_ctx acp_proj._type = CdmAttributeContextType.PROJECTION acp_proj._name = self.fetch_object_definition_name() acp_proj._regarding = proj_directive._owner_ref acp_proj._include_traits = False ac_proj = CdmAttributeContext._create_child_under( proj_directive._res_opt, acp_proj) acp_source = AttributeContextParameters() acp_source._under = ac_proj acp_source._type = CdmAttributeContextType.SOURCE acp_source._name = 'source' acp_source._regarding = None acp_source._include_traits = False ac_source = CdmAttributeContext._create_child_under( proj_directive._res_opt, acp_source) # Initialize the projection context ctx = proj_directive._owner.ctx if proj_directive._owner else None if self.source: source = self.source.fetch_object_definition( proj_directive._res_opt) if source.object_type == CdmObjectType.PROJECTION_DEF: # A Projection proj_context = source._construct_projection_context( proj_directive, ac_source, ras) else: # An Entity Reference acp_source_projection = AttributeContextParameters() acp_source_projection._under = ac_source acp_source_projection._type = CdmAttributeContextType.ENTITY acp_source_projection._name = self.source.named_reference if self.source.named_reference else self.source.explicit_reference.get_name( ) acp_source_projection._regarding = self.source acp_source_projection._include_traits = False ras = self.source._fetch_resolved_attributes( proj_directive._res_opt, acp_source_projection) # type: ResolvedAttributeSet # clean up the context tree, it was left in a bad state on purpose in this call ras.attribute_context._finalize_attribute_context( proj_directive._res_opt, ac_source.at_corpus_path, self.in_document, self.in_document, None, False) # if polymorphic keep original source as previous state poly_source_set = None if proj_directive._is_source_polymorphic: poly_source_set = ProjectionResolutionCommonUtil._get_polymorphic_source_set( proj_directive, ctx, self.source, ras) # Now initialize projection attribute state pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set( proj_directive, ctx, ras, proj_directive._is_source_polymorphic, poly_source_set) proj_context = ProjectionContext(proj_directive, ras.attribute_context) proj_context._current_attribute_state_set = pas_set else: # A type attribute # Initialize projection attribute state pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set( proj_directive, ctx, ras, is_source_polymorphic=False, polymorphic_set=None) proj_context = ProjectionContext(proj_directive, ras.attribute_context) proj_context._current_attribute_state_set = pas_set is_condition_valid = False input_values = InputValues(proj_directive) is_condition_valid = ExpressionTree._evaluate_condition( self.condition, input_values) if is_condition_valid and self.operations and len(self.operations) > 0: # Just in case operations were added programmatically, reindex operations for i in range(len(self.operations)): self.operations[i]._index = i + 1 # Operation acp_gen_attr_set = AttributeContextParameters() acp_gen_attr_set._under = attr_ctx acp_gen_attr_set._type = CdmAttributeContextType.GENERATED_SET acp_gen_attr_set._name = '_generatedAttributeSet' ac_gen_attr_set = CdmAttributeContext._create_child_under( proj_directive._res_opt, acp_gen_attr_set) # Start with an empty list for each projection pas_operations = ProjectionAttributeStateSet( proj_context._current_attribute_state_set._ctx) # The attribute set that the operation will execute on operation_working_attribute_set = None # type: ProjectionAttributeStateSet # The attribute set containing the attributes from the source source_attribute_set = proj_context._current_attribute_state_set # type: ProjectionAttributeStateSet # Specifies if the operation is the first on the list to run first_operation_to_run = True for operation in self.operations: operation_condition = ExpressionTree._evaluate_condition( operation.condition, input_values) if not operation_condition: # Skip this operation if the condition does not evaluate to true continue # If run_sequentially is not true then all the operations will receive the source input # Unless the operation overwrites this behavior using the source_input property source_input = operation.source_input if operation.source_input is not None else not self.run_sequentially # If this is the first operation to run it will get the source attribute set since the operations attribute set starts empty if source_input or first_operation_to_run: proj_context._current_attribute_state_set = source_attribute_set operation_working_attribute_set = pas_operations else: # Needs to create a copy since this set can be modified by the operation proj_context._current_attribute_state_set = pas_operations._copy( ) operation_working_attribute_set = ProjectionAttributeStateSet( proj_context._current_attribute_state_set._ctx) # Evaluate projections and apply to empty state new_pas_operations = operation._append_projection_attribute_state( proj_context, operation_working_attribute_set, ac_gen_attr_set) # If the operations fails or it is not implemented the projection cannot be evaluated so keep previous valid state. if new_pas_operations is not None: first_operation_to_run = False pas_operations = new_pas_operations # If no operation ran successfully pas_operations will be empty if not first_operation_to_run: # Finally update the current state to the projection context proj_context._current_attribute_state_set = pas_operations return proj_context
def _construct_projection_context(self, proj_directive: 'ProjectionDirective', attr_ctx: 'CdmAttributeContext', ras: Optional['ResolvedAttributeSet'] = None) -> 'ProjectionContext': """ A function to construct projection context and populate the resolved attribute set that ExtractResolvedAttributes method can then extract This function is the entry point for projection resolution. This function is expected to do the following 3 things: - Create an condition expression tree & default if appropriate - Create and initialize Projection Context - Process operations """ proj_context = None condition = self.condition if self.condition else "(true)" # create an expression tree based on the condition tree = ExpressionTree() self._condition_expression_tree_root = tree._construct_expression_tree(condition) if attr_ctx: # Add projection to context tree acp_proj = AttributeContextParameters() acp_proj._under = attr_ctx acp_proj._type = CdmAttributeContextType.PROJECTION acp_proj._name = self.fetch_object_definition_name() acp_proj._regarding = proj_directive._owner_ref acp_proj._include_traits = False ac_proj = CdmAttributeContext._create_child_under(proj_directive._res_opt, acp_proj) acp_source = AttributeContextParameters() acp_source._under = ac_proj acp_source._type = CdmAttributeContextType.SOURCE acp_source._name = 'source' acp_source._regarding = None acp_source._include_traits = False ac_source = CdmAttributeContext._create_child_under(proj_directive._res_opt, acp_source) # Initialize the projection context ctx = proj_directive._owner.ctx if proj_directive._owner else None if self.source: source = self.source.fetch_object_definition(proj_directive._res_opt) if source.object_type == CdmObjectType.PROJECTION_DEF: # A Projection proj_context = self.source.explicit_reference._construct_projection_context(proj_directive, ac_source, ras) else: # An Entity Reference acp_source_projection = AttributeContextParameters() acp_source_projection._under = ac_source acp_source_projection._type = CdmAttributeContextType.ENTITY acp_source_projection._name = self.source.named_reference if self.source.named_reference else self.source.explicit_reference.get_name() acp_source_projection._regarding = self.source acp_source_projection._include_traits = False ras = self.source._fetch_resolved_attributes(proj_directive._res_opt, acp_source_projection) # If polymorphic keep original source as previous state poly_source_set = None if proj_directive._is_source_polymorphic: poly_source_set = ProjectionResolutionCommonUtil._get_polymorphic_source_set(proj_directive, ctx, self.source, acp_source_projection) # Now initialize projection attribute state pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set( proj_directive, ctx, ras, proj_directive._is_source_polymorphic, poly_source_set ) proj_context = ProjectionContext(proj_directive, ras.attribute_context) proj_context._current_attribute_state_set = pas_set else: # A type attribute # Initialize projection attribute state pas_set = ProjectionResolutionCommonUtil._initialize_projection_attribute_state_set( proj_directive, ctx, ras, is_source_polymorphic=False, polymorphic_set=None ) proj_context = ProjectionContext(proj_directive, ras.attribute_context) proj_context._current_attribute_state_set = pas_set is_condition_valid = False if self._condition_expression_tree_root: input = InputValues() input.no_max_depth = proj_directive._has_no_maximum_depth input.is_array = proj_directive._is_array input.reference_only = proj_directive._is_reference_only input.normalized = proj_directive._is_normalized input.structured = proj_directive._is_structured input.is_virtual = proj_directive._is_virtual current_depth = proj_directive._current_depth current_depth += 1 input.next_depth = current_depth proj_directive._current_depth = current_depth input.max_depth = proj_directive._maximum_depth input.min_cardinality = proj_directive._cardinality._minimum_number if proj_directive._cardinality else None input.max_cardinality = proj_directive._cardinality._maximum_number if proj_directive._cardinality else None is_condition_valid = ExpressionTree._evaluate_expression_tree(self._condition_expression_tree_root, input) if is_condition_valid and self.operations and len(self.operations) > 0: # Just in case operations were added programmatically, reindex operations for i in range(len(self.operations)): self.operations[i]._index = i + 1 # Operation acp_gen_attr_set = AttributeContextParameters() acp_gen_attr_set._under = attr_ctx acp_gen_attr_set._type = CdmAttributeContextType.GENERATED_SET acp_gen_attr_set._name = '_generatedAttributeSet' ac_gen_attr_set = CdmAttributeContext._create_child_under(proj_directive._res_opt, acp_gen_attr_set) # Start with an empty list for each projection pas_operations = ProjectionAttributeStateSet(proj_context._current_attribute_state_set._ctx) for operation in self.operations: # Evaluate projections and apply to empty state new_pas_operations = operation._append_projection_attribute_state(proj_context, pas_operations, ac_gen_attr_set) # If the operations fails or it is not implemented the projection cannot be evaluated so keep previous valid state. if new_pas_operations is not None: pas_operations = new_pas_operations # Finally update the current state to the projection context proj_context._current_attribute_state_set = pas_operations return proj_context
def _append_projection_attribute_state( self, proj_ctx: 'ProjectionContext', proj_attr_state_set: 'ProjectionAttributeStateSet', attr_ctx: 'CdmAttributeContext') -> 'ProjectionAttributeStateSet': # Create a new attribute context for the operation attr_ctx_op_include_attrs_param = AttributeContextParameters( ) # type: AttributeContextParameters attr_ctx_op_include_attrs_param._under = attr_ctx attr_ctx_op_include_attrs_param._type = CdmAttributeContextType.OPERATION_INCLUDE_ATTRIBUTES attr_ctx_op_include_attrs_param._name = 'operation/index{}/operationIncludeAttributes'.format( self._index) attr_ctx_op_include_attrs = CdmAttributeContext._create_child_under( proj_ctx._projection_directive._res_opt, attr_ctx_op_include_attrs_param) # type: CdmAttributeContext # Get the top-level attribute names for each of the included attributes # Since the include operation allows providing either current state resolved attribute names # or the previous state resolved attribute names, we search for the name in the PAS tree # and fetch the top level resolved attribute names. top_level_include_attribute_names = ProjectionResolutionCommonUtil._get_top_list( proj_ctx, self.include_attributes) # type: Dict[str, str] # Initialize a projection attribute context tree builder with the created attribute context for the operation attr_ctx_tree_builder = ProjectionAttributeContextTreeBuilder( attr_ctx_op_include_attrs) # Index that holds the current attribute name as the key and the attribute as value top_level_include_attribute = { } # type: Dict[str, ProjectionAttributeState] # List of attributes that were not included on the final attribute list removed_attributes = [] # List[ProjectionAttributeState] # Iterate through all the PAS in the PASSet generated from the projection source's resolved attributes for current_PAS in proj_ctx._current_attribute_state_set._states: # Check if the current PASs RA is in the list of attributes to include. if current_PAS._current_resolved_attribute.resolved_name in top_level_include_attribute_names: top_level_include_attribute[ current_PAS._current_resolved_attribute. resolved_name] = current_PAS else: removed_attributes.append(current_PAS) # Loop through the list of attributes in the same order that was specified by the user for key, value in top_level_include_attribute_names.items(): current_PAS = top_level_include_attribute[key] # Get the attribute name the way it appears in the include list include_attribute_name = value # type: str # Create the attribute context parameters and just store it in the builder for now # We will create the attribute contexts at the end attr_ctx_tree_builder._create_and_store_attribute_context_parameters( include_attribute_name, current_PAS, current_PAS._current_resolved_attribute, CdmAttributeContextType.ATTRIBUTE_DEFINITION, current_PAS._current_resolved_attribute. att_ctx, # lineage is the included attribute None) # don't know who will point here yet # Create a projection attribute state for the included attribute by creating a copy of the current state # Copy() sets the current state as the previous state for the new one # We only create projection attribute states for attributes in the include list new_PAS = current_PAS._copy() proj_attr_state_set._add(new_PAS) # Generate attribute context nodes for the attributes that were not included for current_PAS in removed_attributes: # Create the attribute context parameters and just store it in the builder for now # We will create the attribute contexts at the end attr_ctx_tree_builder._create_and_store_attribute_context_parameters( None, current_PAS, current_PAS._current_resolved_attribute, CdmAttributeContextType.ATTRIBUTE_EXCLUDED, current_PAS._current_resolved_attribute. att_ctx, # lineage is the excluded attribute None ) # don't know who will point here, probably nobody, I mean, we got excluded # Create all the attribute contexts and construct the tree attr_ctx_tree_builder._construct_attribute_context_tree(proj_ctx) return proj_attr_state_set
def _append_projection_attribute_state(self, proj_ctx: 'ProjectionContext', proj_output_set: 'ProjectionAttributeStateSet', attr_ctx: 'CdmAttributeContext') -> 'ProjectionAttributeStateSet': # Create a new attribute context for the operation attr_ctx_op_alter_traits_param = AttributeContextParameters() attr_ctx_op_alter_traits_param._under = attr_ctx attr_ctx_op_alter_traits_param._type = CdmAttributeContextType.OPERATION_ALTER_TRAITS attr_ctx_op_alter_traits_param._name = 'operation/index{}/{}'.format(self._index, self.get_name()) attr_ctx_op_alter_traits = CdmAttributeContext._create_child_under(proj_ctx._projection_directive._res_opt, attr_ctx_op_alter_traits_param) # Get the top-level attribute names of the selected attributes to apply # We use the top-level names because the applyTo list may contain a previous name our current resolved attributes had top_level_selected_attribute_names = ProjectionResolutionCommonUtil._get_top_list( proj_ctx, self.apply_to) if self.apply_to is not None else None # type: Dict[str, str] # Iterate through all the PAS in the PASSet generated from the projection source's resolved attributes for current_PAS in proj_ctx._current_attribute_state_set._states: # Check if the current projection attribute state's resolved attribute is in the list of selected attributes # If this attribute is not in the list, then we are including it in the output without changes if top_level_selected_attribute_names is None or current_PAS._current_resolved_attribute.resolved_name in top_level_selected_attribute_names: # Create a new attribute context for the new artifact attribute we will create attr_ctx_new_attr_param = AttributeContextParameters() attr_ctx_new_attr_param._under = attr_ctx_op_alter_traits attr_ctx_new_attr_param._type = CdmAttributeContextType.ATTRIBUTE_DEFINITION attr_ctx_new_attr_param._name = current_PAS._current_resolved_attribute.resolved_name attr_ctx_new_attr = CdmAttributeContext._create_child_under(proj_ctx._projection_directive._res_opt, attr_ctx_new_attr_param) new_res_attr = None if isinstance(current_PAS._current_resolved_attribute.target, ResolvedAttributeSet): # Attribute group # Create a copy of resolved attribute set res_attr_new_copy = current_PAS._current_resolved_attribute.target.copy() new_res_attr = ResolvedAttribute(proj_ctx._projection_directive._res_opt, res_attr_new_copy, current_PAS._current_resolved_attribute.resolved_name, attr_ctx_new_attr) # the resolved attribute group obtained from previous projection operation may have a different set of traits comparing to the resolved attribute target. # We would want to take the set of traits from the resolved attribute. new_res_attr.resolved_traits = current_PAS._current_resolved_attribute.resolved_traits.deep_copy() elif isinstance(current_PAS._current_resolved_attribute.target, CdmAttribute): # Entity Attribute or Type Attribute new_res_attr = self._create_new_resolved_attribute( proj_ctx, attr_ctx_new_attr, current_PAS._current_resolved_attribute, current_PAS._current_resolved_attribute.resolved_name) else: logger.error(self.ctx, self._TAG, CdmOperationAlterTraits._append_projection_attribute_state.__name__, self.at_corpus_path, CdmLogCode.ERR_PROJ_UNSUPPORTED_SOURCE, str(current_PAS._current_resolved_attribute.object_type), self.get_name()) proj_output_set._add(current_PAS) break new_res_attr.resolved_traits = new_res_attr.resolved_traits.merge_set(self._resolved_new_traits(proj_ctx, current_PAS)) self._remove_traits_in_new_attribute(proj_ctx._projection_directive._res_opt, new_res_attr) # Create a projection attribute state for the new attribute with new applied traits by creating a copy of the current state # Copy() sets the current state as the previous state for the new one new_PAS = current_PAS._copy() # Update the resolved attribute to be the new attribute we created new_PAS._current_resolved_attribute = new_res_attr proj_output_set._add(new_PAS) else: # Pass through proj_output_set._add(current_PAS) return proj_output_set