YQ Connector: support managed ClickHouse

Со стороны dqrun можно обратиться к инстансу коннектора, который работает на streaming стенде, и извлечь данные из облачного CH.

1 files changed, 230 insertions, 0 deletions

diff --git a/contrib/libs/clang16/include/clang/Basic/OpenCLOptions.h b/contrib/libs/clang16/include/clang/Basic/OpenCLOptions.h
new file mode 100644
index 0000000000..0d3da049ab
--- /dev/null
+++ b/contrib/libs/clang16/include/clang/Basic/OpenCLOptions.h
@@ -0,0 +1,230 @@
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===--- OpenCLOptions.h ----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Defines the clang::OpenCLOptions class.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_BASIC_OPENCLOPTIONS_H
+#define LLVM_CLANG_BASIC_OPENCLOPTIONS_H
+
+#include "clang/Basic/LangOptions.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace clang {
+
+class DiagnosticsEngine;
+class TargetInfo;
+
+namespace {
+// This enum maps OpenCL version(s) into value. These values are used as
+// a mask to indicate in which OpenCL version(s) extension is a core or
+// optional core feature.
+enum OpenCLVersionID : unsigned int {
+  OCL_C_10 = 0x1,
+  OCL_C_11 = 0x2,
+  OCL_C_12 = 0x4,
+  OCL_C_20 = 0x8,
+  OCL_C_30 = 0x10,
+  OCL_C_ALL = 0x1f,
+  OCL_C_11P = OCL_C_ALL ^ OCL_C_10,              // OpenCL C 1.1+
+  OCL_C_12P = OCL_C_ALL ^ (OCL_C_10 | OCL_C_11), // OpenCL C 1.2+
+};
+
+static inline OpenCLVersionID encodeOpenCLVersion(unsigned OpenCLVersion) {
+  switch (OpenCLVersion) {
+  default:
+    llvm_unreachable("Unknown OpenCL version code");
+  case 100:
+    return OCL_C_10;
+  case 110:
+    return OCL_C_11;
+  case 120:
+    return OCL_C_12;
+  case 200:
+    return OCL_C_20;
+  case 300:
+    return OCL_C_30;
+  }
+}
+
+// Check if OpenCL C version is contained in a given encoded OpenCL C version
+// mask.
+static inline bool isOpenCLVersionContainedInMask(const LangOptions &LO,
+                                                  unsigned Mask) {
+  auto CLVer = LO.getOpenCLCompatibleVersion();
+  OpenCLVersionID Code = encodeOpenCLVersion(CLVer);
+  return Mask & Code;
+}
+
+} // end anonymous namespace
+
+/// OpenCL supported extensions and optional core features
+class OpenCLOptions {
+
+public:
+  // OpenCL C v1.2 s6.5 - All program scope variables must be declared in the
+  // __constant address space.
+  // OpenCL C v2.0 s6.5.1 - Variables defined at program scope and static
+  // variables inside a function can also be declared in the global
+  // address space.
+  // OpenCL C v3.0 s6.7.1 - Variables at program scope or static or extern
+  // variables inside functions can be declared in global address space if
+  // the __opencl_c_program_scope_global_variables feature is supported
+  // C++ for OpenCL inherits rule from OpenCL C v2.0.
+  bool areProgramScopeVariablesSupported(const LangOptions &Opts) const {
+    return Opts.getOpenCLCompatibleVersion() == 200 ||
+           (Opts.getOpenCLCompatibleVersion() == 300 &&
+            isSupported("__opencl_c_program_scope_global_variables", Opts));
+  }
+
+  struct OpenCLOptionInfo {
+    // Does this option have pragma.
+    bool WithPragma = false;
+
+    // Option starts to be available in this OpenCL version
+    unsigned Avail = 100U;
+
+    // Option becomes core feature in this OpenCL versions
+    unsigned Core = 0U;
+
+    // Option becomes optional core feature in this OpenCL versions
+    unsigned Opt = 0U;
+
+    // Is this option supported
+    bool Supported = false;
+
+    // Is this option enabled
+    bool Enabled = false;
+
+    OpenCLOptionInfo() = default;
+    OpenCLOptionInfo(bool Pragma, unsigned AvailV, unsigned CoreV,
+                     unsigned OptV)
+        : WithPragma(Pragma), Avail(AvailV), Core(CoreV), Opt(OptV) {}
+
+    bool isCore() const { return Core != 0U; }
+
+    bool isOptionalCore() const { return Opt != 0U; }
+
+    // Is option available in OpenCL version \p LO.
+    bool isAvailableIn(const LangOptions &LO) const {
+      // In C++ mode all extensions should work at least as in v2.0.
+      return LO.getOpenCLCompatibleVersion() >= Avail;
+    }
+
+    // Is core option in OpenCL version \p LO.
+    bool isCoreIn(const LangOptions &LO) const {
+      return isAvailableIn(LO) && isOpenCLVersionContainedInMask(LO, Core);
+    }
+
+    // Is optional core option in OpenCL version \p LO.
+    bool isOptionalCoreIn(const LangOptions &LO) const {
+      return isAvailableIn(LO) && isOpenCLVersionContainedInMask(LO, Opt);
+    }
+  };
+
+  bool isKnown(llvm::StringRef Ext) const;
+
+  // For core or optional core feature check that it is supported
+  // by a target, for any other option (extension) check that it is
+  // enabled via pragma
+  bool isAvailableOption(llvm::StringRef Ext, const LangOptions &LO) const;
+
+  bool isWithPragma(llvm::StringRef Ext) const;
+
+  // Is supported as either an extension or an (optional) core feature for
+  // OpenCL version \p LO.
+  bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const;
+
+  // Is supported OpenCL core feature for OpenCL version \p LO.
+  // For supported extension, return false.
+  bool isSupportedCore(llvm::StringRef Ext, const LangOptions &LO) const;
+
+  // Is supported optional core OpenCL feature for OpenCL version \p LO.
+  // For supported extension, return false.
+  bool isSupportedOptionalCore(llvm::StringRef Ext,
+                               const LangOptions &LO) const;
+
+  // Is supported optional core or core OpenCL feature for OpenCL version \p
+  // LO. For supported extension, return false.
+  bool isSupportedCoreOrOptionalCore(llvm::StringRef Ext,
+                                     const LangOptions &LO) const;
+
+  // Is supported OpenCL extension for OpenCL version \p LO.
+  // For supported core or optional core feature, return false.
+  bool isSupportedExtension(llvm::StringRef Ext, const LangOptions &LO) const;
+
+  // FIXME: Whether extension should accept pragma should not
+  // be reset dynamically. But it currently required when
+  // registering new extensions via pragmas.
+  void acceptsPragma(llvm::StringRef Ext, bool V = true);
+
+  void enable(llvm::StringRef Ext, bool V = true);
+
+  /// Enable or disable support for OpenCL extensions
+  /// \param Ext name of the extension (not prefixed with '+' or '-')
+  /// \param V value to set for a extension
+  void support(llvm::StringRef Ext, bool V = true);
+
+  OpenCLOptions();
+
+  // Set supported options based on target settings and language version
+  void addSupport(const llvm::StringMap<bool> &FeaturesMap,
+                  const LangOptions &Opts);
+
+  // Disable all extensions
+  void disableAll();
+
+  friend class ASTWriter;
+  friend class ASTReader;
+
+  using OpenCLOptionInfoMap = llvm::StringMap<OpenCLOptionInfo>;
+
+  template <typename... Args>
+  static bool isOpenCLOptionCoreIn(const LangOptions &LO, Args &&... args) {
+    return OpenCLOptionInfo(std::forward<Args>(args)...).isCoreIn(LO);
+  }
+
+  template <typename... Args>
+  static bool isOpenCLOptionAvailableIn(const LangOptions &LO,
+                                        Args &&... args) {
+    return OpenCLOptionInfo(std::forward<Args>(args)...).isAvailableIn(LO);
+  }
+
+  // Diagnose feature dependencies for OpenCL C 3.0. Return false if target
+  // doesn't follow these requirements.
+  static bool diagnoseUnsupportedFeatureDependencies(const TargetInfo &TI,
+                                                     DiagnosticsEngine &Diags);
+
+  // Diagnose that features and equivalent extension are set to same values.
+  // Return false if target doesn't follow these requirements.
+  static bool diagnoseFeatureExtensionDifferences(const TargetInfo &TI,
+                                                  DiagnosticsEngine &Diags);
+
+private:
+  // Option is enabled via pragma
+  bool isEnabled(llvm::StringRef Ext) const;
+
+  OpenCLOptionInfoMap OptMap;
+};
+
+} // end namespace clang
+
+#endif
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif