On discriminator column.

@param builder
the builder
@param columnBuilder
the column builder
@param entityType
the entity type
976941
private void onDiscriminatorColumn(StringBuilder builder, StringBuilder columnBuilder, EntityType entityType)
    {
        String discrColumn = ((AbstractManagedType) entityType).getDiscriminatorColumn();
        String discrValue = ((AbstractManagedType) entityType).getDiscriminatorValue();

        // No need to check for empty or blank, as considering it as valid name
        // for nosql!
        if (discrColumn != null && discrValue != null)
        {
            appendValue(builder, String.class, discrValue, false);
            builder.append(Constants.COMMA);
            appendColumnName(columnBuilder, discrColumn);
            columnBuilder.append(Constants.COMMA); // because only key columns

        }
    }
1165017
private void addDiscriminatorClause(List<String> clauses, EntityType entityType) {
        if (((AbstractManagedType) entityType).isInherited()) {
            String discrColumn = ((AbstractManagedType) entityType).getDiscriminatorColumn();
            String discrValue = ((AbstractManagedType) entityType).getDiscriminatorValue();

            if (discrColumn != null && discrValue != null) {
                if (clauses != null && !clauses.isEmpty()) {
                    filtersQueue.add("AND");
                }

                FilterClause filterClause = new FilterClause(discrColumn, "=", discrValue, discrColumn);
                filtersQueue.add(filterClause);
            }
        }
    }
208829
private void addDiscriminator(Map<String, Object> values, EntityType entityType)
    {
        String discrColumn = ((AbstractManagedType) entityType).getDiscriminatorColumn();
        String discrValue = ((AbstractManagedType) entityType).getDiscriminatorValue();

        // No need to check for empty or blank, as considering it as valid name
        // for nosql!
        if (discrColumn != null && discrValue != null)
        {
            values.put(discrColumn, discrValue);
        }
    }
719914
public static void addConstructorArgReference(BeanDefinitionBuilder builder, String beanReference) {
        if (StringUtils.hasText(beanReference)) {
            builder.addConstructorArgReference(beanReference);
        }
    }
427479
private function remapBuilderColumns(Builder $builder): void {
    if($builder->aggregate === null) {
      if($builder->columns === ['*']) {
        $builder->columns = array_keys($this->to_db);
      }

      if(is_string($builder->columns)) {
        $builder->columns = [$builder->columns];
      }

      $this->remapColumns($builder->columns);
    } else {
      if($builder->aggregate['columns'] == ['*']) {
        return;
      }

      $this->remapColumns($builder->aggregate['columns'], false);
    }
  }
389803
def apply(self, builder, model):
        
        builder.where_null(model.get_qualified_deleted_at_column())

        self.extend(builder)
496949
private void onInheritedProperty(TableInfo tableInfo, EntityType entityType)
    {
        String discrColumn = ((AbstractManagedType) entityType).getDiscriminatorColumn();

        if (discrColumn != null)
        {
            ColumnInfo columnInfo = new ColumnInfo();
            columnInfo.setColumnName(discrColumn);
            columnInfo.setType(String.class);
            columnInfo.setIndexable(true);

            IndexInfo idxInfo = new IndexInfo(discrColumn);
            tableInfo.addColumnInfo(columnInfo);
            tableInfo.addToIndexedColumnList(idxInfo);
        }
    }
732501
private static boolean isSelector( StringBuilder builder ) {
        int length = builder.length();
        if( length == 0 ) {
            return false;
        }
        switch( builder.charAt( 0 ) ) { 
            case '.': // Mixin
            case '#': // Mixin
                break;
            default:
                return true;
        }
        for( int i = 1; i < length; i++ ) {
            char ch = builder.charAt( i );
            switch( ch ) {
                case '>':
                case ':':
                    return true;
            }
        }
        return false;
    }
627620
@Nonnull
	public static <T1, T2> LBiObjCharPredicate<T1, T2> biObjCharPredicateFrom(Consumer<LBiObjCharPredicateBuilder<T1, T2>> buildingFunction) {
		LBiObjCharPredicateBuilder builder = new LBiObjCharPredicateBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
618315
public <E> EntityScannerBuilder<E> getScannerBuilder(
      EntityMapper<E> entityMapper) {
    EntityScannerBuilder<E> builder = new BaseEntityScanner.Builder<E>(pool,
        tableName, entityMapper);
    for (ScanModifier scanModifier : scanModifiers) {
      builder.addScanModifier(scanModifier);
    }
    return builder;
  }
755466
@Override
    public <T> RegistrationAnnotatedBindingBuilder<T> register(Class<T> type) {
        return new RegistrationBindingBuilderImpl<>(binder, type);
    }
453014
private void generateBuilderClass() {
        if (data.isSkipBuilderGeneration()) {
            return;
        }
        List<PropertyGen> nonDerived = nonDerivedProperties();
        generateSeparator();
        String finalType = data.isTypeFinal() ? "final " : "";
        addLine(1, "/**");
        addLine(1, " * The bean-builder for {@code " + data.getTypeRaw() + "}.");
        if (data.isTypeGeneric()) {
            for (int j = 0; j < data.getTypeGenericCount(); j++) {
                addLine(1, " * @param " + data.getTypeGenericName(j, true) + "  the type");
            }
        }
        addLine(1, " */");
        String superBuilder;
        if (data.isSubClass()) {
            superBuilder = data.getSuperTypeRaw() + ".Builder" + data.getSuperTypeGeneric(true);
        } else if (data.isEffectiveBuilderScopeVisible()) {
            data.ensureImport(DirectFieldsBeanBuilder.class);
            superBuilder = "DirectFieldsBeanBuilder<" + data.getTypeNoExtends() + ">";
        } else {
            data.ensureImport(DirectPrivateBeanBuilder.class);
            superBuilder = "DirectPrivateBeanBuilder<" + data.getTypeNoExtends() + ">";
        }
        if (data.isConstructable()) {
            addLine(1, data.getEffectiveBuilderScope() + "static " + finalType +
                    "class Builder" + data.getTypeGeneric(true) + " extends " + superBuilder + " {");
        } else {
            addLine(1, data.getEffectiveBuilderScope() + "abstract static " + finalType +
                    "class Builder" + data.getTypeGeneric(true) + " extends " + superBuilder + " {");
        }
        if (nonDerived.size() > 0) {
            addBlankLine();
            generateBuilderProperties();
        }
        addBlankLine();
        generateBuilderConstructorNoArgs();
        generateBuilderConstructorCopy();
        generateIndentedSeparator();
        generateBuilderGet();
        generateBuilderSet();
        generateBuilderOtherSets();
        if (data.isConstructable()) {
            generateBuilderBuild();
        }
        generateIndentedSeparator();
        generateBuilderPropertySetMethods();
        generateIndentedSeparator();
        generateBuilderToString();
        addLine(1, "}");
        addBlankLine();
    }
405904
@Nonnull
	public static <R> LBiDblFunctionBuilder<R> biDblFunction(Consumer<LBiDblFunction<R>> consumer) {
		return new LBiDblFunctionBuilder(consumer);
	}
1132250
private void buildDiscriminatorNodes(DiscriminatorNode node) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "buildDiscriminatorNodes: " + node);
        }
        DiscriminatorNode dn = node;
        if (dn == null) {
            return;
        }
        DiscriminatorNode newDN = null, lastDN = null;
        discriminators = new DiscriminatorNode(dn.disc, dn.weight, null, null);
        discAL.add(dn.disc);
        Channel chan = dn.disc.getChannel();
        addChannel(chan);
        newDN = discriminators;
        lastDN = discriminators;
        while (dn.next != null) {
            dn = dn.next;
            newDN = new DiscriminatorNode(dn.disc, dn.weight, null, lastDN);
            lastDN.next = newDN;
            lastDN = newDN;
            discAL.add(dn.disc);
            chan = dn.disc.getChannel();
            addChannel(chan);
        }
    }
350916
public function apply(Builder $builder, Model $model) {
    $subclassTypes = array_keys($model->getSingleTableTypeMap());

    if (!empty($subclassTypes) ) {
      $builder->whereIn($model->getQualifiedSingleTableTypeColumn(), $subclassTypes);
    }
  }
630488
private void addDiscriminatorColumn(Row row, EntityType entityType, Table schemaTable)
    {
        String discrColumn = ((AbstractManagedType) entityType).getDiscriminatorColumn();
        String discrValue = ((AbstractManagedType) entityType).getDiscriminatorValue();

        // No need to check for empty or blank, as considering it as valid name
        // for nosql!
        if (discrColumn != null && discrValue != null)
        {
            // Key
            // Key key = Key.createKey(majorKeyComponent, discrColumn);

            byte[] valueInBytes = PropertyAccessorHelper.getBytes(discrValue);
            NoSqlDBUtils.add(schemaTable.getField(discrColumn), row, discrValue, discrColumn);

        }
    }
722802
@Nonnull
	public static LByteToDblFunction byteToDblFunctionFrom(Consumer<LByteToDblFunctionBuilder> buildingFunction) {
		LByteToDblFunctionBuilder builder = new LByteToDblFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}