@crossbind/port-gdal-wasi 2.0.0-beta.50

package/dist/prebuilt/wasi-wasm32-st-release/include/ogr_swq.h

@@ -0,0 +1,534 @@
+/******************************************************************************
+ *
+ * Component: OGDI Driver Support Library
+ * Purpose: Generic SQL WHERE Expression Evaluator Declarations.
+ * Author: Frank Warmerdam <warmerdam@pobox.com>
+ *
+ ******************************************************************************
+ * Copyright (C) 2001 Information Interoperability Institute (3i)
+ * Copyright (c) 2010-2013, Even Rouault <even dot rouault at spatialys.com>
+ * Permission to use, copy, modify and distribute this software and
+ * its documentation for any purpose and without fee is hereby granted,
+ * provided that the above copyright notice appear in all copies, that
+ * both the copyright notice and this permission notice appear in
+ * supporting documentation, and that the name of 3i not be used
+ * in advertising or publicity pertaining to distribution of the software
+ * without specific, written prior permission.  3i makes no
+ * representations about the suitability of this software for any purpose.
+ * It is provided "as is" without express or implied warranty.
+ ****************************************************************************/
+
+#ifndef SWQ_H_INCLUDED_
+#define SWQ_H_INCLUDED_
+
+#ifndef DOXYGEN_SKIP
+
+#include "cpl_conv.h"
+#include "cpl_string.h"
+#include "ogr_core.h"
+
+#include <list>
+#include <map>
+#include <vector>
+#include <set>
+
+#if defined(_WIN32) && !defined(strcasecmp)
+#define strcasecmp stricmp
+#endif
+
+// Used for swq_summary.oSetDistinctValues and oVectorDistinctValues
+#define SZ_OGR_NULL "__OGR_NULL__"
+
+typedef enum
+{
+    SWQ_OR,
+    SWQ_AND,
+    SWQ_NOT,
+    SWQ_EQ,
+    SWQ_NE,
+    SWQ_GE,
+    SWQ_LE,
+    SWQ_LT,
+    SWQ_GT,
+    SWQ_LIKE,
+    SWQ_ILIKE,
+    SWQ_ISNULL,
+    SWQ_IN,
+    SWQ_BETWEEN,
+    SWQ_ADD,
+    SWQ_SUBTRACT,
+    SWQ_MULTIPLY,
+    SWQ_DIVIDE,
+    SWQ_MODULUS,
+    SWQ_CONCAT,
+    SWQ_SUBSTR,
+    SWQ_HSTORE_GET_VALUE,
+
+    SWQ_AVG,
+    SWQ_AGGREGATE_BEGIN = SWQ_AVG,
+    SWQ_MIN,
+    SWQ_MAX,
+    SWQ_COUNT,
+    SWQ_SUM,
+    SWQ_STDDEV_POP,
+    SWQ_STDDEV_SAMP,
+    SWQ_AGGREGATE_END = SWQ_STDDEV_SAMP,
+
+    SWQ_CAST,
+    SWQ_CUSTOM_FUNC,  /* only if parsing done in bAcceptCustomFuncs mode */
+    SWQ_ARGUMENT_LIST /* temporary value only set during parsing and replaced by
+                         something else at the end */
+} swq_op;
+
+typedef enum
+{
+    SWQ_INTEGER,
+    SWQ_INTEGER64,
+    SWQ_FLOAT,
+    SWQ_STRING,
+    SWQ_BOOLEAN,    // integer
+    SWQ_DATE,       // string
+    SWQ_TIME,       // string
+    SWQ_TIMESTAMP,  // string
+    SWQ_GEOMETRY,
+    SWQ_NULL,
+    SWQ_OTHER,
+    SWQ_ERROR
+} swq_field_type;
+
+#define SWQ_IS_INTEGER(x) ((x) == SWQ_INTEGER || (x) == SWQ_INTEGER64)
+
+typedef enum
+{
+    SNT_CONSTANT,
+    SNT_COLUMN,
+    SNT_OPERATION
+} swq_node_type;
+
+class swq_field_list;
+class swq_expr_node;
+class swq_select;
+class OGRGeometry;
+
+struct CPL_UNSTABLE_API swq_evaluation_context
+{
+    bool bUTF8Strings = false;
+};
+
+typedef swq_expr_node *(*swq_field_fetcher)(swq_expr_node *op,
+                                            void *record_handle);
+typedef swq_expr_node *(*swq_op_evaluator)(
+    swq_expr_node *op, swq_expr_node **sub_field_values,
+    const swq_evaluation_context &sContext);
+typedef swq_field_type (*swq_op_checker)(
+    swq_expr_node *op, int bAllowMismatchTypeOnFieldComparison);
+
+class swq_custom_func_registrar;
+
+class CPL_UNSTABLE_API swq_expr_node
+{
+    swq_expr_node *Evaluate(swq_field_fetcher pfnFetcher, void *record,
+                            const swq_evaluation_context &sContext,
+                            int nRecLevel);
+    void reset();
+
+  public:
+    swq_expr_node();
+    swq_expr_node(const swq_expr_node &);
+    swq_expr_node(swq_expr_node &&);
+
+    swq_expr_node &operator=(const swq_expr_node &);
+    swq_expr_node &operator=(swq_expr_node &&);
+
+    bool operator==(const swq_expr_node &) const;
+
+    explicit swq_expr_node(const char *);
+    explicit swq_expr_node(int);
+    explicit swq_expr_node(GIntBig);
+    explicit swq_expr_node(double);
+    explicit swq_expr_node(OGRGeometry *);
+    explicit swq_expr_node(swq_op);
+
+    ~swq_expr_node();
+
+    void MarkAsTimestamp();
+    CPLString UnparseOperationFromUnparsedSubExpr(char **apszSubExpr);
+    char *Unparse(swq_field_list *, char chColumnQuote);
+    void Dump(FILE *fp, int depth);
+    swq_field_type Check(swq_field_list *, int bAllowFieldsInSecondaryTables,
+                         int bAllowMismatchTypeOnFieldComparison,
+                         swq_custom_func_registrar *poCustomFuncRegistrar);
+    swq_expr_node *Evaluate(swq_field_fetcher pfnFetcher, void *record,
+                            const swq_evaluation_context &sContext);
+    swq_expr_node *Clone();
+
+    void ReplaceBetweenByGEAndLERecurse();
+    void ReplaceInByOrRecurse();
+    void PushNotOperationDownToStack();
+
+    void RebalanceAndOr();
+
+    bool HasReachedMaxDepth() const;
+
+    swq_node_type eNodeType = SNT_CONSTANT;
+    swq_field_type field_type = SWQ_INTEGER;
+
+    /* only for SNT_OPERATION */
+    void PushSubExpression(swq_expr_node *);
+    void ReverseSubExpressions();
+    swq_op nOperation = SWQ_OR;
+    int nSubExprCount = 0;
+    swq_expr_node **papoSubExpr = nullptr;
+
+    /* only for SNT_COLUMN */
+    int field_index = 0;
+    int table_index = 0;
+    char *table_name = nullptr;
+
+    /* only for SNT_CONSTANT */
+    int is_null = false;
+    int64_t int_value = 0;
+    double float_value = 0.0;
+    OGRGeometry *geometry_value = nullptr;
+
+    /* shared by SNT_COLUMN, SNT_CONSTANT and also possibly SNT_OPERATION when
+     */
+    /* nOperation == SWQ_CUSTOM_FUNC */
+    char *string_value = nullptr; /* column name when SNT_COLUMN */
+
+    // May be transiently used by swq_parser.h, but should not be relied upon
+    // after parsing. swq_col_def.bHidden captures it afterwards.
+    bool bHidden = false;
+
+    // Recursive depth of this expression, taking into account papoSubExpr.
+    int nDepth = 1;
+
+    static CPLString QuoteIfNecessary(const CPLString &, char chQuote = '\'');
+    static CPLString Quote(const CPLString &, char chQuote = '\'');
+};
+
+typedef struct
+{
+    const char *pszName;
+    swq_op eOperation;
+    swq_op_evaluator pfnEvaluator;
+    swq_op_checker pfnChecker;
+} swq_operation;
+
+class CPL_UNSTABLE_API swq_op_registrar
+{
+  public:
+    static const swq_operation *GetOperator(const char *);
+    static const swq_operation *GetOperator(swq_op eOperation);
+};
+
+class CPL_UNSTABLE_API swq_custom_func_registrar
+{
+  public:
+    virtual ~swq_custom_func_registrar();
+
+    virtual const swq_operation *GetOperator(const char *) = 0;
+};
+
+typedef struct
+{
+    char *data_source;
+    char *table_name;
+    char *table_alias;
+} swq_table_def;
+
+class CPL_UNSTABLE_API swq_field_list
+{
+  public:
+    int count;
+    char **names;
+    swq_field_type *types;
+    int *table_ids;
+    int *ids;
+
+    int table_count;
+    swq_table_def *table_defs;
+};
+
+class CPL_UNSTABLE_API swq_parse_context
+{
+  public:
+    swq_parse_context()
+        : nStartToken(0), pszInput(nullptr), pszNext(nullptr),
+          pszLastValid(nullptr), bAcceptCustomFuncs(FALSE), poRoot(nullptr),
+          poCurSelect(nullptr)
+    {
+    }
+
+    int nStartToken;
+    const char *pszInput;
+    const char *pszNext;
+    const char *pszLastValid;
+    int bAcceptCustomFuncs;
+
+    swq_expr_node *poRoot;
+
+    swq_select *poCurSelect;
+};
+
+/* Compile an SQL WHERE clause into an internal form.  The field_list is
+** the list of fields in the target 'table', used to render where into
+** field numbers instead of names.
+*/
+int CPL_UNSTABLE_API swqparse(swq_parse_context *context);
+int CPL_UNSTABLE_API swqlex(swq_expr_node **ppNode, swq_parse_context *context);
+void CPL_UNSTABLE_API swqerror(swq_parse_context *context, const char *msg);
+
+int CPL_UNSTABLE_API swq_identify_field(const char *table_name,
+                                        const char *token,
+                                        swq_field_list *field_list,
+                                        swq_field_type *this_type,
+                                        int *table_id);
+
+CPLErr CPL_UNSTABLE_API
+swq_expr_compile(const char *where_clause, int field_count, char **field_list,
+                 swq_field_type *field_types, int bCheck,
+                 swq_custom_func_registrar *poCustomFuncRegistrar,
+                 swq_expr_node **expr_root);
+
+CPLErr CPL_UNSTABLE_API
+swq_expr_compile2(const char *where_clause, swq_field_list *field_list,
+                  int bCheck, swq_custom_func_registrar *poCustomFuncRegistrar,
+                  swq_expr_node **expr_root);
+
+/*
+** Evaluation related.
+*/
+int CPL_UNSTABLE_API swq_test_like(const char *input, const char *pattern);
+
+swq_expr_node CPL_UNSTABLE_API *
+SWQGeneralEvaluator(swq_expr_node *, swq_expr_node **,
+                    const swq_evaluation_context &sContext);
+swq_field_type CPL_UNSTABLE_API
+SWQGeneralChecker(swq_expr_node *node, int bAllowMismatchTypeOnFieldComparison);
+swq_expr_node CPL_UNSTABLE_API *
+SWQCastEvaluator(swq_expr_node *, swq_expr_node **,
+                 const swq_evaluation_context &sContext);
+swq_field_type CPL_UNSTABLE_API
+SWQCastChecker(swq_expr_node *node, int bAllowMismatchTypeOnFieldComparison);
+const char CPL_UNSTABLE_API *SWQFieldTypeToString(swq_field_type field_type);
+
+/****************************************************************************/
+
+#define SWQP_ALLOW_UNDEFINED_COL_FUNCS 0x01
+
+#define SWQM_SUMMARY_RECORD 1
+#define SWQM_RECORDSET 2
+#define SWQM_DISTINCT_LIST 3
+
+typedef enum
+{
+    SWQCF_NONE = 0,
+    SWQCF_AVG = SWQ_AVG,
+    SWQCF_MIN = SWQ_MIN,
+    SWQCF_MAX = SWQ_MAX,
+    SWQCF_COUNT = SWQ_COUNT,
+    SWQCF_SUM = SWQ_SUM,
+    SWQCF_STDDEV_POP = SWQ_STDDEV_POP,
+    SWQCF_STDDEV_SAMP = SWQ_STDDEV_SAMP,
+    SWQCF_CUSTOM
+} swq_col_func;
+
+typedef struct
+{
+    swq_col_func col_func;
+    char *table_name;
+    char *field_name;
+    char *field_alias;
+    int table_index;
+    int field_index;
+    swq_field_type field_type;
+    swq_field_type target_type;
+    OGRFieldSubType target_subtype;
+    int field_length;
+    int field_precision;
+    int distinct_flag;
+    bool bHidden;
+    OGRwkbGeometryType eGeomType;
+    int nSRID;
+    swq_expr_node *expr;
+} swq_col_def;
+
+class CPL_UNSTABLE_API swq_summary
+{
+  public:
+    struct Comparator
+    {
+        bool bSortAsc;
+        swq_field_type eType;
+
+        Comparator() : bSortAsc(true), eType(SWQ_STRING)
+        {
+        }
+
+        bool operator()(const CPLString &, const CPLString &) const;
+    };
+
+    //! Return the sum, using Kahan-Babuska-Neumaier algorithm.
+    // Cf cf KahanBabushkaNeumaierSum of https://en.wikipedia.org/wiki/Kahan_summation_algorithm#Further_enhancements
+    double sum() const
+    {
+        return sum_only_finite_terms ? sum_acc + sum_correction : sum_acc;
+    }
+
+    GIntBig count = 0;
+
+    std::vector<CPLString> oVectorDistinctValues{};
+    std::set<CPLString, Comparator> oSetDistinctValues{};
+    bool sum_only_finite_terms = true;
+    // Sum accumulator. To get the accurate sum, use the sum() method
+    double sum_acc = 0.0;
+    // Sum correction term.
+    double sum_correction = 0.0;
+    double min = 0.0;
+    double max = 0.0;
+
+    // Welford's online algorithm for variance:
+    // https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
+    double mean_for_variance = 0.0;
+    double sq_dist_from_mean_acc = 0.0;  // "M2"
+
+    CPLString osMin{};
+    CPLString osMax{};
+};
+
+typedef struct
+{
+    char *table_name;
+    char *field_name;
+    int table_index;
+    int field_index;
+    int ascending_flag;
+} swq_order_def;
+
+typedef struct
+{
+    int secondary_table;
+    swq_expr_node *poExpr;
+} swq_join_def;
+
+class CPL_UNSTABLE_API swq_select_parse_options
+{
+  public:
+    swq_custom_func_registrar *poCustomFuncRegistrar;
+    int bAllowFieldsInSecondaryTablesInWhere;
+    int bAddSecondaryTablesGeometryFields;
+    int bAlwaysPrefixWithTableName;
+    int bAllowDistinctOnGeometryField;
+    int bAllowDistinctOnMultipleFields;
+
+    swq_select_parse_options()
+        : poCustomFuncRegistrar(nullptr),
+          bAllowFieldsInSecondaryTablesInWhere(FALSE),
+          bAddSecondaryTablesGeometryFields(FALSE),
+          bAlwaysPrefixWithTableName(FALSE),
+          bAllowDistinctOnGeometryField(FALSE),
+          bAllowDistinctOnMultipleFields(FALSE)
+    {
+    }
+};
+
+class CPL_UNSTABLE_API swq_select
+{
+    void postpreparse();
+
+    CPL_DISALLOW_COPY_ASSIGN(swq_select)
+
+  public:
+    swq_select();
+    ~swq_select();
+
+    int query_mode = 0;
+
+    char *raw_select = nullptr;
+
+    int PushField(swq_expr_node *poExpr, const char *pszAlias,
+                  bool distinct_flag, bool bHidden);
+
+    int PushExcludeField(swq_expr_node *poExpr);
+
+    int result_columns() const
+    {
+        return static_cast<int>(column_defs.size());
+    }
+
+    std::vector<swq_col_def> column_defs{};
+    std::vector<swq_summary> column_summary{};
+
+    int PushTableDef(const char *pszDataSource, const char *pszTableName,
+                     const char *pszAlias);
+    int table_count = 0;
+    swq_table_def *table_defs = nullptr;
+
+    void PushJoin(int iSecondaryTable, swq_expr_node *poExpr);
+    int join_count = 0;
+    swq_join_def *join_defs = nullptr;
+
+    swq_expr_node *where_expr = nullptr;
+
+    void PushOrderBy(const char *pszTableName, const char *pszFieldName,
+                     int bAscending);
+    int order_specs = 0;
+    swq_order_def *order_defs = nullptr;
+
+    void SetLimit(GIntBig nLimit);
+    GIntBig limit = -1;
+
+    void SetOffset(GIntBig nOffset);
+    GIntBig offset = 0;
+
+    swq_select *poOtherSelect = nullptr;
+    void PushUnionAll(swq_select *poOtherSelectIn);
+
+    CPLErr preparse(const char *select_statement,
+                    int bAcceptCustomFuncs = FALSE);
+    CPLErr expand_wildcard(swq_field_list *field_list,
+                           int bAlwaysPrefixWithTableName);
+    CPLErr parse(swq_field_list *field_list,
+                 swq_select_parse_options *poParseOptions);
+
+    char *Unparse();
+
+    bool bExcludedGeometry = false;
+
+  private:
+    bool IsFieldExcluded(int src_index, const char *table, const char *field);
+
+    // map of EXCLUDE columns keyed according to the index of the
+    // asterisk with which it should be associated. key of -1 is
+    // used for column lists that have not yet been associated with
+    // an asterisk.
+    std::map<int, std::list<swq_col_def>> m_exclude_fields{};
+};
+
+/* This method should generally be invoked with pszValue set, except when
+ * called on a non-DISTINCT column definition of numeric type (SWQ_BOOLEAN,
+ * SWQ_INTEGER, SWQ_INTEGER64, SWQ_FLOAT), in which case pdfValue should
+ * rather be set.
+ */
+const char CPL_UNSTABLE_API *swq_select_summarize(swq_select *select_info,
+                                                  int dest_column,
+                                                  const char *pszValue,
+                                                  const double *pdfValue);
+
+int CPL_UNSTABLE_API swq_is_reserved_keyword(const char *pszStr);
+
+char CPL_UNSTABLE_API *OGRHStoreGetValue(const char *pszHStore,
+                                         const char *pszSearchedKey);
+
+#ifdef GDAL_COMPILATION
+void swq_fixup(swq_parse_context *psParseContext);
+swq_expr_node *swq_create_and_or_or(swq_op op, swq_expr_node *left,
+                                    swq_expr_node *right);
+int swq_test_like(const char *input, const char *pattern, char chEscape,
+                  bool insensitive, bool bUTF8Strings);
+#endif
+
+#endif /* #ifndef DOXYGEN_SKIP */
+
+#endif /* def SWQ_H_INCLUDED_ */