TranslateFilterSyntax Methode

In diesem Thema

Diese Methode wird aufgerufen wenn ein Teil eines Filterausdrucks übersetzt werden soll.

Syntax

Visual Basic
C#
C++/CLI

'Deklaration
 
Function TranslateFilterSyntax( _
   ByVal part As LlExpressionPart, _
   ByRef name As Object, _
   ByVal argumentCount As Integer, _
   ByVal arguments() As Object _
) As Object

object TranslateFilterSyntax( 
   LlExpressionPart part,
   ref object name,
   int argumentCount,
   object[] arguments
)

Object^ TranslateFilterSyntax( 
   LlExpressionPart part,
   Object^% name,
   int argumentCount,
   array<Object^>^ arguments
)

Parameter

part

Beschreibt die aktuell übergebenen Argumente.

name

Primary Locale Summary

Name der übersetzt werden soll. Wenn part z.B. LlExpressionPart.Text ist, enthält dieses Objekt den Index und kann auf einen String gesetzt werden um den Parameter Namen zu verwenden. Der Wert dieses Parameters wird dann später an die ApplyAdvancedFilter Methode übergeben.

Wenn der Parameter part LlExpressionPart.RelationEqual entspricht, kann der Name "@ARG:MULTIVALUE" sein. In diesem Fall enthält die rechte Seite von arguments[1] eine kommaseparierte Liste von Werten zum Vergleich zu arguments[0].

Wenn der Parameter part LlExpressionPart.Function ist, kann der Parameter auch ein Leerstring sein. In diesem Fall liefern Sie die Übersetzung für einen geklammerten Ausdruck (vgl. Beispiel unten) zurück.

argumentCount

Anzahl an Argumenten, die nicht null sind.

arguments

Die Teile einer Formel die übersetzt werden sollen.

Rückgabetyp

Der übersetzte Ausdruck oder null wenn eine Übersetzung nicht möglich ist.

Beispiele

Dieses Snippet ist Teil der Implementierung im DbCommandSetDataProvider und zeigt, wie man mit Parameternamen arbeitet:

public object TranslateFilterSyntax(LlExpressionPart part, ref object name, int argumentCount, object[] arguments)
{
    switch (part)
    {
        case LlExpressionPart.Text:
            {
                if (arguments[0] != null)
                {
                    name = String.Format(_commandSet.ParameterFormatMap[_dbCommand.Connection.GetType()], String.Format("LLAdvancedFilterKeyVal{0}", (int)name));
                    return arguments[0];
                }
                else
                {
                    return "NULL";
                }
            }
        default:
            return null;
    }
}

Dieser Ausschnitt ist die Implementierung dieser Methode für den AdoDataProvider:

public object TranslateFilterSyntax(LlExpressionPart part, ref object name, int argumentCount, object[] arguments)
{
    switch (part)
    {
        case LlExpressionPart.Unknown:
            {
                return null;
            }
        case LlExpressionPart.Boolean:
            {
                if (arguments[0] != null)
                {
                    return ((bool)arguments[0] ? "true" : "false");
                }
                else
                {
                    return "null";
                }
            }
        case LlExpressionPart.Text:
            {
                if (arguments[0] != null)
                {
                    return String.Format("'{0}'", arguments[0]);
                }
                else
                {
                    return "null";
                }
            }
        case LlExpressionPart.Number:
            {
                if (arguments[0] != null)
                {
                    return arguments[0].ToString();
                }
                else
                {
                    return "null";
                }
            }
        case LlExpressionPart.Date:
            {
                if (arguments[0] != null)
                {
                    return String.Format("#{0}#", ((DateTime)arguments[0]).ToString(CultureInfo.InvariantCulture));
                }
                else
                {
                    return "null";
                }
            }
        case LlExpressionPart.UnaryOperatorSign:
            {
                return (String.Format("(-({0}))", arguments[0]));
            }
        case LlExpressionPart.UnaryOperatorNegation:
            {
                return (String.Format("(NOT ({0}))", arguments[0]));
            }
        case LlExpressionPart.BinaryOperatorAdd:
            {
                return (String.Format("({0}+{1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.BinaryOperatorSubstract:
            {
                return (String.Format("({0}-{1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.BinaryOperatorMultiply:
            {
                return (String.Format("({0}*{1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.BinaryOperatorDivide:
            {
                return (String.Format("({0}/{1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.BinaryOperatorModulo:
            {
                return (String.Format("({0}%{1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.RelationXor:
            {
                return (String.Format("(({0} AND NOT {1}) OR (NOT {0} AND {1}))", arguments[0], arguments[1]));
            }
        case LlExpressionPart.RelationOr:
            {
                return (String.Format("({0} OR {1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.RelationAnd:
            {
                return (String.Format("({0} AND {1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.RelationEqual:
            {
                if (!name.ToString().Equals("@ARG:MULTIVALUE", StringComparison.InvariantCultureIgnoreCase))
                {
                    return (String.Format("({0} = {1})", arguments[0], arguments[1]));
                }
                else
                {
                    return (String.Format("({0} IN ({1}))", arguments[0], arguments[1]));
                }
            }
        case LlExpressionPart.RelationNotEqual:
            {
                if (!name.ToString().Equals("@ARG:MULTIVALUE", StringComparison.InvariantCultureIgnoreCase))
                {
                    return (String.Format("({0} <> {1})", arguments[0], arguments[1]));
                }
                else
                {
                    return (String.Format("(NOT {0} IN ({1}))", arguments[0], arguments[1]));
                }
            }
        case LlExpressionPart.RelationLarger:
            {
                return (String.Format("({0} > {1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.RelationLargerEqual:
            {
                return (String.Format("({0} >= {1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.RelationSmaller:
            {
                return (String.Format("({0} < {1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.RelationSmallerEqual:
            {
                return (String.Format("({0} <= {1})", arguments[0], arguments[1]));
            }
        case LlExpressionPart.Function:
            {
                switch (name.ToString().ToUpper())
                {
                    case "":
                        return (String.Format("({0})", arguments[0]));
                    case "ISNULL":
                        return (String.Format("(ISNULL({0}))", arguments[0]));
                    case "STARTSWITH":
                        return (String.Format("({0} LIKE '{1}%')", arguments[0], EscapeArgumentForRowFilter(arguments[1].ToString())));
                    case "ENDSWITH":
                        return (String.Format("({0} LIKE '%{1}')", arguments[0], EscapeArgumentForRowFilter(arguments[1].ToString())));
                    case "CONTAINS":
                        return (String.Format("({0} LIKE '{1}')", arguments[0], EscapeArgumentForRowFilter(arguments[1].ToString())));
                    case "MID$":
                        {
                            long arg1 = Convert.ToInt64(arguments[1]);
                            if (arg1 < 0)
                            {
                                return null;
                            }
                            if (argumentCount == 3)
                                return (String.Format("(SUBSTRING({0},{1},{2}))", arguments[0], arg1 + 1, arguments[2]));
                            else
                                return String.Empty;
                        }
                    case "LEFT$":
                        return (String.Format("(SUBSTRING({0},1,{1}))", arguments[0], arguments[1]));
                    case "LEN":
                        return (String.Format("(LEN({0}))", arguments[0]));
                    case "EMPTY":
                        if (argumentCount == 1)
                            return (String.Format("(LEN({0})=0)", arguments[0]));
                        else
                            return (String.Format("(LEN(TRIM({0}))=0)", arguments[0]));
                    case "ATRIM$":
                        return (String.Format("(TRIM({0}))", arguments[0]));
                    case "COND":
                        return (String.Format("(IIF({0},{1},{2}))", arguments[0], arguments[1], arguments[2]));
                    case "DATEINRANGE":
                        return (String.Format("(({0} >= {1}) AND ({0} <= {2}))", arguments[0], arguments[1], arguments[2]));
                    case "NUMINRANGE":
                        return (String.Format("(({0} >= {1}) AND ({0} <= {2}))", arguments[0], arguments[1], arguments[2]));
                }
                return null;
            }
        case LlExpressionPart.Field:
            {
                if (arguments[0] == null || !arguments[0].ToString().StartsWith(TableName + "."))
                {
                    return null;
                }
                return String.Format("[{0}]", arguments[0].ToString().Substring(TableName.Length + 1));
            }
        default:
            return null;
     
    }
}

Anforderungen

Plattformen: Windows 10 (Version 21H2 - 22H2), Windows 11 (21H2 - 23H2), Windows Server 2016 - 2022
.NET: .NET Framework 4.8, .NET 6, .NET 7, .NET 8

Siehe auch

Referenz

IAdvancedFiltering Schnittstelle
IAdvancedFiltering Member

Feedback senden