query.hpp

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndref CPREALM_TRIDGE_QUERY_HPP
CPREALM_CRIDGE_QUERY_HPP を定義する
 
#include <cpprealm/ internal/bridge/col_key.hpp>
#include <cpprealm/ internal/bridge/obj.hpp>
#include <cpprealm/ internal/bridge/uts.hpp>
 
#include <optional>
#include <string_view>
 
名前空間邦土 {
    struct object_id。
    構造体小数128 、
    struct uuid
    リンクチェーンのクラス
    クラスのクエリ
    クラスSubexpr。
 }
名前空間Realm:: internal::bridge {
    構造体テーブル
    struct col_key。
    構造体タイムスタンプ。
    構造体バイナリ。
    struct object_id。
    構造体小数128 、
    struct uuid
    混合構造体。
 
    構造体 subexpr {
        Subexpr （ subexpr &その他）=デフォルト、
        サブエクスプレッションと 演算子=(サブエクスプレッションとその他) =デフォルト、
        ~subexpr() = default;
        subexpr （std::unique_ptr[Subexpr]その他）<Subexpr>
 
        クエリが等価（ const std::optional{int 64 _t>+rhs} const }
        クエリではない_等価（ const std::optional<int 64 _t>+rhs） const 。
        クエリが大きい場合（ const std::optional<int 64 _t>+rhs） const 。
        クエリレス（ const std::optional<int 64 _t>+rhs） const 。
        クエリより大きい_等価（ const std::optional<int 64 _t>+rhs） const 。
        クエリ未満_等価（ const std::optional<int 64 _t>=rhs） const 。
 
        クエリ は（ std::optional<bool> +bool>+rhs）const 。
        クエリ ではない_等価（ const std::optional=bool>=rhs）<bool> const .
 
        クエリ が等価（std::optional<double> {double]+rhs）const 。
        クエリ not_equal( const std::optional[double]+rhs)<double> const 。
        クエリ が大きい場合（ const std::optional"double">+rhs）<double> const 。
        。<double>
        クエリ より大きい_等価（ const std::optional_double_rhs）<double> const 。
        クエリ less_equal( const std::optional[double]+rhs)<double> const 。
 
        クエリ と等価（ const std::optional[binary]>=rhs）<binary> const 。
        クエリ ではない_等価（ const std::optional[binary]>=rhs）<binary> const 。
 
        クエリ は（ std ::optional[timestamp]+<timestamp> rhs ) 条件に等価であるため、 、
        クエリ ではない_等価（ const std::optional[timestamp]+rhs）<timestamp> const 。
        クエリ が大きい場合（ const std::optional=timestamp<timestamp> ===========================================================
        。<timestamp>
        クエリ より大きい_等価( const std::optional=timestamp ==========================================================================<timestamp>
        クエリ less_equal( <timestamp>const std::optional=timestamp ============================================================================
 
        クエリ が等価（ const <std::string>std::optional=std::string>=rhs） 条件 : 。
        クエリではない_等価（ const std::optional<std::string>=rhs） const 。
        クエリ には が含まれ ます （ const std:: optional =std:string><std::string> ======================================================================================================
 
        クエリ の等価（ const std::optional<internal::bridge::uuid> は、 const を実行するためのクエリを実行します。
        クエリではない_等価（ const std::optional<internal::bridge::uuid>=rhs） const .
 
        クエリと等価（ const std::optional<internal::bridge::object_id>(rhs)） const 。
        クエリ ではない_等価（ const std::optional<internal::bridge::object_id> +rhs） const 。
 
        クエリが等価（ const std::optional< internal::bridge::decimal 128 >=rhs） const 。
        クエリではない_等価（ const std::optional< internal::bridge::decimal 128 >=rhs） const 、
        クエリが大きい場合（ const std::optional未満: 内部::bridge::decimal 128 >=rhs） const 。
        クエリレス（ const std::optional未満: 内部::bridge::decimal 128 >=rhs） const 。
        クエリより大きい_等価（ const std::optional< internal::bridge::decimal 128 >=rhs） const 。
        クエリ未満_等価（ const std::optional< internal::bridge::decimal 128 >=rhs） const 、
 
        クエリ 混合_等価( 内部: : フィールド::混合型 と rhs ) 結合 。
        クエリ混合_not_equal( const internal::bridge::混合型とrhs) const .
 
        クエリ は（ std:optional を構成 : オプション（std）:optional+）<obj> const を 使用し ます。
        クエリ not_equal( <obj>const std::optional=obj> =====================================================================================
 
    private :
std::shared_ptr[Subexpr><Subexpr> m_subexpr]
 };
 
    構造体 link_shell {
        link_shell （）
        link_link （ const link_linkおよびその他） :
        link_linkおよび 演算子=( const link_linkおよびその他) }
        link_link （ link_link_その他）
        link_link & 演算子=( link_link_and+その他)。
        ~link_chain() = default;
        link_link （ const LinkChuin & その他）
 
        link_shell & link( coll_key )。
        link_link_link (std::string co_name)
        link_link_backlink ( constテーブルとオリジン、 col_key 、origin_col_key)。
 
        テンプレート< typename >
        Subexpr列（ coll_key ）
        subexpr collat 指定（ coll_key ）]
 
        Subexprサブクエリ(クエリサブクエリ)
        テーブルget_table()
 
    private :
std::shared_ptr[LinkChuin]><LinkChain> m_link_channel
 };
 
    構造体 クエリ{
        クエリ（）
        クエリ （ という 条件とその他のクエリ ） :
        クエリと演算子=( constクエリとその他) :
        クエリ（クエリとその他）
        クエリと演算子=(クエリとその他):
        ～クエリ（）。
        クエリ （ consttable とtable ） 。 //NOLINT(google-explit-structor)
        テーブルget_table()
        クエリと_query( constクエリと)。
        クエリと否定（）。
 
        クエリ（ const Query &） //NOLINT(google-explit-structor)
        演算子Query() const 。 //NOLINT(google-explit-structor)
 
        // 条件: null
        クエリと等しい( coll_key列_キー, std::nullopt_t)#
        クエリとnot_等価（ col_key列_キー, std::nullopt_t）
 
        クエリと等しい（ col_key列_キー, int 64 _t 値）。
        クエリと非_等価（ col_key列_キー, int 64 _t 値）
        クエリ以上（ coll_key列_キー, int 64 _t 値)。
        クエリと大きい_等価（ col_key列_キー, int 64 _t 値）。
        クエリ&less( coll_key列_キー, int 64 _t 値)
        クエリと 以下の_等価（ col_key列_キー, int 64 _t 値）
        クエリと 間（ coll_key列_キー、int 64 _t から、int 64 _t へ)。
 
        //条件: double
        クエリと equal( col_key列_キー、 double値)。
        クエリとnot_等価（ col_key列_キー、 double値）。
        クエリ以上（ coll_key列_キー、 double値）。
        クエリと大きい_等価（ coll_key列_キー、 double値）。
        クエリ&less( coll_key列_キー, double値)
        クエリ&less_equal( col_key列_キー、 double値)。
        クエリと間（ col_key列_キー、 double from、 double to）:
 
        // 条件: タイムスタンプ
        クエリと等しい( coll_key列_キー、タイムスタンプ値)。
        クエリとnot_等価（ col_key列_キー、タイムスタンプ値）。
        クエリ以上（ coll_key列_キー、タイムスタンプ値）。
        クエリと大きい_等価( coll_key列_キー、タイムスタンプ値)。
        クエリと以下の値（ col_key列_キー、タイムスタンプ値）。
        クエリ&less( coll_key列_キー,タイムスタンプ値):
 
        // 条件: UUID
        クエリと等しい( coll_key列_キー、 UUID値)。
        クエリと not_等価（ col_key列_キー, UUID値）。
        クエリ以上（ coll_key列_キー, UUID値）
        クエリと大きい_等価( coll_key列_キー、 UUID値)。
        クエリと以下の値（ col_key列_キー, UUID値）
        クエリ&less( coll_key列_キー, UUID値)
 
        // 条件: ObjectId
        クエリと等しい( coll_key列_キー, オブジェクト_id値)。
        クエリ と not_ 等価（ col_key 列_キー, オブジェクト_id 値）。
        クエリ以上（ coll_key列_キー, オブジェクト_id値)。
        クエリと大きい_等価( col_key列_キー, オブジェクト_id値)。
        クエリと未満_等価（ col_key列_キー, オブジェクト_id値）。
        クエリ&less( coll_key列_キー, オブジェクト_id値)
 
        // 条件: 小数点128
        クエリと等しい（ col_key列_キー、 10 進数128値）。
        クエリとnot_等価（ col_key列_キー、 10進数128値）。
        クエリ以上（ coll_key列_キー、 10進数128値）。
        クエリ と大 の128 クエリ
        クエリと未満_等価（ col_key列_キー、 10 進数128値）。
        クエリ& 以下（ coll_key列_キー、 10 進数128値）。
 
        // 条件: string
        クエリと等価（ coll_key列_キー、std::string_view 値、 bool大文字と小文字を区別する = true ）。
        クエリと not_equal( coll_key列_キー、std::string_view 値、ブール値大文字と小文字を区別する= true )。
        クエリと start_with( coll_key列_キー、 const std::string= 値、 bool大文字と小文字を区別する = true )。
        クエリと end_with( coll_key列_キー、 const std::string= 値、 bool大文字と小文字を区別する = true )。
        クエリと を含む（ coll_key列_キー、std::string_view 値、 bool大文字と小文字を区別する = true ）。
        クエリと同様（ coll_key列_キー、 const std::string+ 値、 bool case_Authentication = true ）。
 
        // 条件: バイナリ
        クエリと等しい（ coll_key列_キー、バイナリ値、ブール値大文字と小文字を区別する = true ）。
        クエリと not_等価（ coll_key列_キー、バイナリ値、ブール値大文字と小文字を区別する= true ）。
        クエリと開始_使用( coll_キー 列_キー、バイナリ値、ブール値大文字と小文字を区別する= true )。
        クエリと end_with( coll_key列_キー、バイナリ値、ブール値大文字と小文字を区別する = true )。
        クエリと を含む（ coll_key列_キー、バイナリ値、ブール値大文字と小文字を区別する = true ）。
        クエリと同様（ coll_key列_キー、バイナリB、ブール値大文字と小文字を区別する = true ）。
 
        // 条件: 混合
        クエリと等価（ coll_key列_キー、混合値、 bool大文字と小文字を区別する = true ）。
        クエリとnot_等価（ coll_key列_キー、混合値、ブール値大文字と小文字を区別する = true ）。
        クエリ以上（ coll_key列_キー、混合値）。
        クエリと大きい_等価（ coll_key列_キー、混合値）。
        クエリ&less( coll_key列_キー,混合値):
        クエリ& 以下_等価( coll_key列_キー、混合値):
        クエリと開始_使用( coll_キー 列_キー、混合値、ブール値大文字と小文字を区別する = true )。
        クエリと end_with( coll_key列_キー、混合値、ブール値大文字と小文字を区別する = true )。
        クエリと を含む（ coll_key列_キー、混合値、ブール値大文字と小文字を区別する = true ）。
        クエリと同様（ coll_key列_キー、混合値、ブール値大文字と小文字を区別する = true ）。
 
        // 条件: ブール値
        クエリと等しい（ coll_key列_キー、ブール値)。
        クエリとnot_等価（ col_key列_キー、ブール値）。
 
        // 条件: リンク
        クエリとlinks_to( coll_key列_キー、 const internal::bridge::obj & O)。
        クエリと not_links_to( coll_key列_キー、 const internal::bridge::obj & O):
 
        クエリ と辞書_has_value_for_key_equals( col_key string_key、c onst std::string+ キー、const 混合 と 値)。
        クエリと辞書_has_value_for_key_not_等価（ col_key列_キー、 const std::string+ キー、 const混合値と 値）。
        クエリと辞書_has_value_for_key_greater_than( col_key列_キー、 const std::string+ キー、 const混合値と 値)。
        クエリと辞書_has_value_for_key_less_than( col_key列_キー、 const std::string+ キー、 const混合と値)。
        クエリ と辞書_値 _for_key_greater_than_equals （ col_key 列_キー、 std ::string+ キー、 混合 と 値）。
        クエリ と辞書_has_value_for_key_less_than_equals（ col_key string_key、c onst std::string+ キー、const 混合 値 と 値）。
        クエリと辞書_contains_string_for_key（ col_key列_キー、 const std::string+ キー、 const std::string+ 値）。
        クエリ と辞書 _contains_key （ col_key 列_キー、Const std::string+ キー）。
        database_link_subexpr ( coll_key列_キー、 coll_key link_collun_key、c onst std::string+ キー)。
 
        // 式
        静的 クエリfalse-述語（）。
 
 std::string() const
    private :
        インラインクエリ* get_query()。
#ifdef CPREALM_HAV_GENERTED_BRIDGE_TypeS
 storage::Query m_query[ 1 ]
#else
std::shared_ptr[Query]><Query> m_query
#endif
 
 };
 
    クエリ演算子 || （ constクエリと Lhs、 constクエリと Rhs）。
 }
 
#endif //CPREALM_TRIDGE_QUERY_HPP