text stringlengths 70 351k | source stringclasses 4
values |
|---|---|
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
fn compile_atom(
&mut self,
atom: &Rc<Atom>,
tokens: &mut TokenStream,
) -> Result<proc_macro2::Ident, String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use rustc_hash::{FxHashMap, FxHashSet};
fn detect_graph_cycles(&self) -> Result<(), String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use rustc_hash::{FxHashMap, FxHashSet};
fn cycle_dfs(
&self,
node_id: usize,
explored: &mut FxHashSet<usize>,
visited: &mut FxHashSet<usize>,
order: &mut Vec<usize>,
) -> Result<Option<Vec<usize>>, String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use syn::{parse::Parse, Token};
fn parse_rhs_atom(input: syn::parse::ParseStream<'_>) -> syn::Result<Atom> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
use syn::{parse::Parse, Token};
fn parse_atom_type_inner(
input: syn::parse::ParseStream<'_>,
key: syn::Ident,
relation: Relation,
) -> syn::Result<AtomType> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
{
Self::Crate => write!(f, "crate"),<|fim_suffix|>
<|fim_middle|>
Self::Extern => write!(f, "euclid"),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
{
Self::LessThan => "< ",<|fim_suffix|>
<|fim_middle|>
Self::GreaterThan => "> ",
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use proc_macro2::{Span, TokenStream};
use syn::{parse::Parse, Token};
pub(crate) fn knowledge_inner(ts: TokenStream) -> syn::Result<TokenStream> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
use rustc_hash::{FxHashMap, FxHashSet};
use syn::{parse::Parse, Token};
fn compile(&mut self, program: Program) -> Result<TokenStream, String> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
fn next_node_ident(&mut self) -> (proc_macro2::Ident, usize) {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn register_rule(&mut self, rule: &Rule) -> Result<(), String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
fn register_edge(&mut self, from: usize, to: usize) -> Result<(), String> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn register_node(&mut self, atom: Rc<Atom>) -> usize {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use syn::{parse::Parse, Token};
fn parse(input: syn::parse::ParseStream<'_>) -> syn::Result<Self> {
let lookahead = input.lookahead1();
if lookahead.peek(Token![crate]) {
input.parse::<Token![crate]>()?;
Ok(Self::Crate)
} else if lookahead.peek(Token![extern]) {
input.parse::<Token![extern]>()?;
Ok(Self::Extern)
} else {
Err(lookahead.error())
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
use std::{
fmt::{Display, Formatter},
hash::Hash,
rc::Rc,
};
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/euclid_macros/src/inner/knowledge.rs | crate: euclid_macros
fn to_string(&self, key: &str) -> String {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use serde::Serialize;
fn for_string() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
{#[cfg_attr(all(feature = "alloc", feature = "serde"), derive(Serialize))]<|fim_suffix|>
<|fim_middle|>
Ok(())}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use masking::ZeroizableSecret;
use serde::Serialize;
fn without_serialize() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
{#[cfg_attr(feature = "serde", derive(Serialize))]<|fim_suffix|>
<|fim_middle|>
Ok(())}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use masking::SerializableSecret;
use masking::ZeroizableSecret;
use serde::Serialize;
fn basic() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
use masking::Secret;
use masking::SerializableSecret;
use masking::ZeroizableSecret;
use serde::Serialize;
fn basic() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
{#[cfg_attr(feature = "serde", derive(Serialize))]#[derive(Clone, Debug, PartialEq, Eq)]<|fim_suffix|>
<|fim_middle|>
// endOk(())}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/tests/basic.rs | crate: masking
fn zeroize(&mut self) {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_value<V>(&mut self, value: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_struct(
self,
_name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn end(self) -> Result<Value, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
serde::ser::SerializeMap::serialize_entry(self, key, value)
} | ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn end(self) -> Result<Value, Self::Error> {
self.inner.end()
} | ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_value<V>(&mut self, value: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
let value = value.serialize(self.ser.clone())?;
self.inner.serialize_value(&value)?;
Ok(())
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
fn serialize_key<V>(&mut self, key: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn end(self) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_field<V>(&mut self, value: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_element<V>(&mut self, value: &V) -> Result<(), Self::Error>
where
V: ?Sized + Serialize,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
T: ?Sized + Display,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_struct_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
_len: usize,
) -> Result<Self::SerializeStructVariant, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_struct(
self,
_name: &'static str,
len: usize,
) -> Result<Self::SerializeStruct, Self::Error> {
self.serialize_map(Some(len))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_tuple_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_tuple_struct(
self,
_name: &'static str,
len: usize,
) -> Result<Self::SerializeTupleStruct, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
T: ?Sized + Serialize,
{
value.serialize(self)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_newtype_variant<T>(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: ?Sized + Serialize,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_newtype_struct<T>(
self,
_name: &'static str,
value: &T,
) -> Result<Self::Ok, Self::Error>
where
T: ?Sized + Serialize,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_unit_variant(
self,
_name: &'static str,
_variant_index: u32,
variant: &'static str,
) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_char(self, value: char) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_f64(self, float: f64) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_f32(self, float: f32) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u128(self, value: u128) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u64(self, value: u64) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u32(self, value: u32) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u16(self, value: u16) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_u8(self, value: u8) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i128(self, value: i128) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i64(self, value: i64) -> Result<Self::Ok, Self::Error> {
self.inner.serialize_i64(value)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i32(self, value: i32) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i16(self, value: i16) -> Result<Self::Ok, Self::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_i8(self, value: i8) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize_bool(self, value: bool) -> Result<Self::Ok, Self::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn clone(&self) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
use pii_serializer::PIISerializer;
pub(super) fn pii_serialize<
V: Serialize,
T: std::fmt::Debug + PeekInterface<V>,
S: Serializer,
>(
value: &T,
serializer: S,
) -> Result<S::Ok, S::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
use serde_json::{value::Serializer as JsonValueSerializer, Value};
fn masked_serialize(&self) -> Result<Value, serde_json::Error> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use erased_serde::Serialize as ErasedSerialize;
pub use serde::{de, Deserialize, Serialize, Serializer};
use serde_json::{value::Serializer as JsonValueSerializer, Value};
use pii_serializer::PIISerializer;
/// Masked serialization.
///
/// the default behaviour for secrets is to serialize in exposed format since the common use cases
/// for storing the secret to database or sending it over the network requires the secret to be exposed
/// This method allows to serialize the secret in masked format if needed for logs or other insecure exposures
pub fn masked_serialize<T: Serialize>(value: &T) -> Result<Value, serde_json::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/serde.rs | crate: masking
pub use serde::{de, Deserialize, Serialize, Serializer};
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: de::Deserializer<'de>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Checks whether the data is normal (not masked).
/// Returns `true` if the data is wrapped in the `Normal` variant,
/// returns `false` otherwise.
pub fn is_normal(&self) -> bool {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
use crate::{ExposeInterface, Secret};
/// Create a new Masked data
pub fn new_masked(item: Secret<T>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
fn from(value: &str) -> Self {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
fn into_masked(self) -> Maskable<Self::Output> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Checks whether the data is normal (not masked).
/// Returns `true` if the data is wrapped in the `Normal` variant,
/// returns `false` otherwise.
pub fn is_normal(&self) -> bool {
matches!(self, Self::Normal(_))
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Checks whether the data is masked.
/// Returns `true` if the data is wrapped in the `Masked` variant,
/// returns `false` otherwise.
pub fn is_masked(&self) -> bool {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Create a new non-masked data
pub fn new_normal(item: T) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
use crate::{ExposeInterface, Secret};
/// Create a new Masked data
pub fn new_masked(item: Secret<T>) -> Self {
Self::Masked(item)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
/// Get the inner data while consuming self
pub fn into_inner(self) -> T {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/maskable.rs | crate: masking
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
{
Self::Masked(secret_value) => std::fmt::Debug::fmt(secret_value, f),<|fim_suffix|>
<|fim_middle|>
Self::Normal(value) => std::fmt::Debug::fmt(value, f),
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use core::fmt;
use bytes::BytesMut;
use serde::de::{self, Deserialize};
use super::{PeekInterface, ZeroizableSecret};
fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn peek(&self) -> &BytesMut {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
/// Wrap bytes in `SecretBytesMut`
pub fn new(bytes: impl Into<BytesMut>) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use core::fmt;
use bytes::BytesMut;
use serde::de::{self, Deserialize};
use super::{PeekInterface, ZeroizableSecret};
fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
where
V: de::SeqAccess<'de>,
{
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
where
E: de::Error,
{
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use core::fmt;
use serde::de::{self, Deserialize};
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("byte array")
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
fn from(bytes: BytesMut) -> Self {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn peek_mut(&mut self) -> &mut BytesMut {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
use serde::de::{self, Deserialize};
fn peek(&self) -> &BytesMut {
&self.0
} | ast_fragments |
// file: hyperswitch/crates/masking/src/bytes.rs | crate: masking
use bytes::BytesMut;
/// Wrap bytes in `SecretBytesMut`
pub fn new(bytes: impl Into<BytesMut>) -> Self {
Self(bytes.into())
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/core.rs | crate: analytics
use api_models::analytics::GetInfoResponse;
use crate::{types::AnalyticsDomain, utils};
pub async fn get_domain_info(
domain: AnalyticsDomain,
) -> crate::errors::AnalyticsResult<GetInfoResponse> {
let info = match domain {
AnalyticsDomain::Payments => GetInfoResponse {
metrics: utils::get_payment_metrics_info(),
download_dimensions: None,
dimensions: utils::get_payment_dimensions(),
},
AnalyticsDomain::PaymentIntents => GetInfoResponse {
metrics: utils::get_payment_intent_metrics_info(),
download_dimensions: None,
dimensions: utils::get_payment_intent_dimensions(),
},
AnalyticsDomain::Refunds => GetInfoResponse {
metrics: utils::get_refund_metrics_info(),
download_dimensions: None,
dimensions: utils::get_refund_dimensions(),
},
AnalyticsDomain::Frm => GetInfoResponse {
metrics: utils::get_frm_metrics_info(),
download_dimensions: None,
dimensions: utils::get_frm_dimensions(),
},
AnalyticsDomain::SdkEvents => GetInfoResponse {
metrics: utils::get_sdk_event_metrics_info(),
download_dimensions: None,
dimensions: utils::get_sdk_event_dimensions(),
},
AnalyticsDomain::AuthEvents => GetInfoResponse {
metrics: utils::get_auth_event_metrics_info(),
download_dimensions: None,
dimensions: utils::get_auth_event_dimensions(),
},
AnalyticsDomain::ApiEvents => GetInfoResponse {
metrics: utils::get_api_event_metrics_info(),
download_dimensions: None,
dimensions: utils::get_api_event_dimensions(),
},
AnalyticsDomain::Dispute => GetInfoResponse {
metrics: utils::get_dispute_metrics_info(),
download_dimensions: None,
dimensions: utils::get_dispute_dimensions(),
},
};
Ok(info)
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/core.rs | crate: analytics
use api_models::analytics::GetInfoResponse;
use crate::{types::AnalyticsDomain, utils};
pub async fn get_domain_info(
domain: AnalyticsDomain,
) -> crate::errors::AnalyticsResult<GetInfoResponse> {
{<|fim_suffix|>
<|fim_middle|>
}}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use error_stack::ResultExt;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(match self {
Self::Sum {
field,
partition_by,
order_by,
alias,
} => {
format!(
"sum({}) over ({}{}){}",
field
.to_sql(table_engine)
.attach_printable("Failed to sum window")?,
partition_by.as_ref().map_or_else(
|| "".to_owned(),
|partition_by| format!("partition by {}", partition_by.to_owned())
),
order_by.as_ref().map_or_else(
|| "".to_owned(),
|(order_column, order)| format!(
" order by {} {}",
order_column.to_owned(),
order
)
),
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
Self::RowNumber {
field: _,
partition_by,
order_by,
alias,
} => {
format!(
"row_number() over ({}{}){}",
partition_by.as_ref().map_or_else(
|| "".to_owned(),
|partition_by| format!("partition by {}", partition_by.to_owned())
),
order_by.as_ref().map_or_else(
|| "".to_owned(),
|(order_column, order)| format!(
" order by {} {}",
order_column.to_owned(),
order
)
),
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
})
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use error_stack::ResultExt;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
Ok(match self {
Self::Count { field: _, alias } => {
format!(
"count(*){}",
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
Self::Sum { field, alias } => {
format!(
"sum({}){}",
field
.to_sql(table_engine)
.attach_printable("Failed to sum aggregate")?,
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
Self::Min { field, alias } => {
format!(
"min({}){}",
field
.to_sql(table_engine)
.attach_printable("Failed to min aggregate")?,
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
Self::Max { field, alias } => {
format!(
"max({}){}",
field
.to_sql(table_engine)
.attach_printable("Failed to max aggregate")?,
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
Self::Percentile {
field,
alias,
percentile,
} => {
format!(
"percentile_cont(0.{}) within group (order by {} asc){}",
percentile.map_or_else(|| "50".to_owned(), |percentile| percentile.to_string()),
field
.to_sql(table_engine)
.attach_printable("Failed to percentile aggregate")?,
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
Self::DistinctCount { field, alias } => {
format!(
"count(distinct {}){}",
field
.to_sql(table_engine)
.attach_printable("Failed to distinct count aggregate")?,
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use time::PrimitiveDateTime;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use time::PrimitiveDateTime;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let currency: Option<DBEnumWrapper<Currency>> =
row.try_get("currency").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_status: Option<DBEnumWrapper<RefundStatus>> =
row.try_get("refund_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_type: Option<DBEnumWrapper<RefundType>> =
row.try_get("refund_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let profile_id: Option<String> = row.try_get("profile_id").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_reason: Option<String> = row.try_get("refund_reason").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let refund_error_message: Option<String> =
row.try_get("refund_error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let total: Option<bigdecimal::BigDecimal> = row.try_get("total").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let count: Option<i64> = row.try_get("count").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
// Removing millisecond precision to get accurate diffs against clickhouse
let start_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("start_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
let end_bucket: Option<PrimitiveDateTime> = row
.try_get::<Option<PrimitiveDateTime>, _>("end_bucket")?
.and_then(|dt| dt.replace_millisecond(0).ok());
Ok(Self {
currency,
refund_status,
connector,
refund_type,
profile_id,
refund_reason,
refund_error_message,
total,
count,
start_bucket,
end_bucket,
})
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_enums::{
AuthenticationConnectors, AuthenticationStatus, DecoupledAuthenticationType, TransactionStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let authentication_status: Option<DBEnumWrapper<AuthenticationStatus>> =
row.try_get("authentication_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let trans_status: Option<DBEnumWrapper<TransactionStatus>> =
row.try_get("trans_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_type: Option<DBEnumWrapper<DecoupledAuthenticationType>> =
row.try_get("authentication_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let error_message: Option<String> = row.try_get("error_message").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let authentication_connector: Option<DBEnumWrapper<AuthenticationConnectors>> = row
.try_get("authentication_connector")
.or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let message_version: Option<String> =
row.try_get("message_version").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let acs_reference_number: Option<String> =
row.try_get("acs_reference_number").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
authentication_status,
trans_status,
authentication_type,
error_message,
authentication_connector,
message_version,
acs_reference_number,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use error_stack::ResultExt;
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
fn to_sql(&self, table_engine: &TableEngine) -> error_stack::Result<String, ParsingError> {
{
Self::Count { field: _, alias } => {
format!(
"count(*){}",
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}<|fim_suffix|>
<|fim_middle|>
Self::DistinctCount { field, alias } => {
format!(
"count(distinct {}){}",
field
.to_sql(table_engine)
.attach_printable("Failed to distinct count aggregate")?,
alias.map_or_else(|| "".to_owned(), |alias| format!(" as {}", alias))
)
}
}
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
e => Err(e),
})?;
Ok(Self {
dispute_stage,
dispute_status,
connector,
connector_status,
currency,
})
}
}
impl<'a> FromRow<'a, PgRow> for super::disputes::metrics::DisputeMetricRow {
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let dispute_stage: Option<DBEnumWrapper<DisputeStage>> =
row.try_get("dispute_stage").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let dispute_status: Option<DBEnumWrapper<DisputeStatus>> =
row.try_get("dispute_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let connector: Option<String> = row.try_get("connector").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
{
ColumnNotFound(_) => Ok(Default::default()),<|fim_suffix|>
<|fim_middle|>
e => Err(e),
}
} | ast_fragments |
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use api_models::{
analytics::{frm::FrmTransactionType, refunds::RefundType},
enums::{DisputeStage, DisputeStatus},
};
use diesel_models::enums::{
AttemptStatus, AuthenticationType, Currency, FraudCheckStatus, IntentStatus, PaymentMethod,
RefundStatus,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
fn from_row(row: &'a PgRow) -> sqlx::Result<Self> {
let frm_name: Option<String> = row.try_get("frm_name").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_status: Option<DBEnumWrapper<FraudCheckStatus>> =
row.try_get("frm_status").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
let frm_transaction_type: Option<DBEnumWrapper<FrmTransactionType>> =
row.try_get("frm_transaction_type").or_else(|e| match e {
ColumnNotFound(_) => Ok(Default::default()),
e => Err(e),
})?;
Ok(Self {
frm_name,
frm_status,
frm_transaction_type,
})
} | ast_fragments |
<|fim_prefix|>
// file: hyperswitch/crates/analytics/src/sqlx.rs | crate: analytics
use common_utils::{
errors::{CustomResult, ParsingError},
DbConnectionParams,
};
use sqlx::{
postgres::{PgArgumentBuffer, PgPoolOptions, PgRow, PgTypeInfo, PgValueRef},
Decode, Encode,
Error::ColumnNotFound,
FromRow, Pool, Postgres, Row,
};
use super::{
health_check::HealthCheck,
query::{Aggregate, ToSql, Window},
types::{
AnalyticsCollection, AnalyticsDataSource, DBEnumWrapper, LoadRow, QueryExecutionError,
TableEngine,
},
};
async fn deep_health_check(&self) -> CustomResult<(), QueryExecutionError> {
<|fim_suffix|>
<|fim_middle|>
}
| ast_fragments |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.