use crate::errors::BigQueryError;
use crate::testing::matcher::BigQueryFakeQuery;
use crate::testing::state::TableKey;
use crate::{BigQueryDmlStats, BigQueryResult, BigQueryStatementType, BigQueryTableSchema};
use arrow_array::RecordBatch;
use gcloud_sdk::google::cloud::bigquery::v2::{QueryParameter, QueryParameterValue};
use gcloud_sdk::tonic::Code;
use std::fmt::{Debug, Display, Formatter};
use std::num::NonZeroUsize;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
#[derive(Clone, Debug)]
pub struct BigQueryFakeRule {
counter: Arc<RuleCounter>,
}
#[derive(Debug)]
struct RuleCounter {
description: String,
times: Option<NonZeroUsize>,
calls: AtomicUsize,
}
impl BigQueryFakeRule {
fn new(description: String, times: Option<NonZeroUsize>) -> Self {
Self {
counter: Arc::new(RuleCounter {
description,
times,
calls: AtomicUsize::new(0),
}),
}
}
pub(super) fn unlimited(description: String) -> Self {
Self::new(description, None)
}
pub(super) fn limited(description: String, times: Option<usize>) -> BigQueryResult<Self> {
match times.map(NonZeroUsize::new) {
Some(None) => Err(BigQueryError::invalid_parameters(
"times",
format!("{description} would answer no call; leave times unset or pass 1 or more"),
)),
Some(times) => Ok(Self::new(description, times)),
None => Ok(Self::unlimited(description)),
}
}
pub fn calls(&self) -> usize {
self.counter.calls.load(Ordering::SeqCst)
}
fn claim(&self) -> bool {
let calls = &self.counter.calls;
let mut current = calls.load(Ordering::SeqCst);
loop {
if self
.counter
.times
.is_some_and(|times| current >= times.get())
{
return false;
}
match calls.compare_exchange_weak(
current,
current + 1,
Ordering::SeqCst,
Ordering::SeqCst,
) {
Ok(_) => return true,
Err(actual) => current = actual,
}
}
}
pub(super) fn count(&self) {
self.counter.calls.fetch_add(1, Ordering::SeqCst);
}
fn listed(&self) -> String {
let calls = self.calls();
match self.counter.times {
Some(times) => format!(
"{} (answered {calls} of times({times}))",
self.counter.description
),
None => format!("{} (answered {calls})", self.counter.description),
}
}
fn shortfall(&self) -> Option<String> {
let times = self.counter.times?.get();
let calls = self.calls();
(calls != times).then(|| {
format!(
"{} answered {calls} of its times({times}) calls",
self.counter.description
)
})
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum BigQueryFakeFault {
#[non_exhaustive]
Status {
code: BigQueryFakeCode,
message: String,
},
ConnectionDropped,
Hang,
}
impl BigQueryFakeFault {
pub fn status(code: BigQueryFakeCode, message: impl Into<String>) -> Self {
Self::Status {
code,
message: message.into(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BigQueryFakeCode {
Cancelled,
Unknown,
InvalidArgument,
DeadlineExceeded,
NotFound,
AlreadyExists,
PermissionDenied,
ResourceExhausted,
FailedPrecondition,
Aborted,
OutOfRange,
Unimplemented,
Internal,
Unavailable,
DataLoss,
Unauthenticated,
}
impl BigQueryFakeCode {
pub(crate) fn grpc_code(self) -> Code {
match self {
BigQueryFakeCode::Cancelled => Code::Cancelled,
BigQueryFakeCode::Unknown => Code::Unknown,
BigQueryFakeCode::InvalidArgument => Code::InvalidArgument,
BigQueryFakeCode::DeadlineExceeded => Code::DeadlineExceeded,
BigQueryFakeCode::NotFound => Code::NotFound,
BigQueryFakeCode::AlreadyExists => Code::AlreadyExists,
BigQueryFakeCode::PermissionDenied => Code::PermissionDenied,
BigQueryFakeCode::ResourceExhausted => Code::ResourceExhausted,
BigQueryFakeCode::FailedPrecondition => Code::FailedPrecondition,
BigQueryFakeCode::Aborted => Code::Aborted,
BigQueryFakeCode::OutOfRange => Code::OutOfRange,
BigQueryFakeCode::Unimplemented => Code::Unimplemented,
BigQueryFakeCode::Internal => Code::Internal,
BigQueryFakeCode::Unavailable => Code::Unavailable,
BigQueryFakeCode::DataLoss => Code::DataLoss,
BigQueryFakeCode::Unauthenticated => Code::Unauthenticated,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum BigQueryFakeRpc {
GetQueryResults,
GetJob,
CancelJob,
CreateReadSession,
ReadRows,
GetWriteStream,
CreateWriteStream,
AppendRows,
FlushRows,
FinalizeWriteStream,
BatchCommitWriteStreams,
GetTable,
InsertTable,
PatchTable,
UpdateTable,
DeleteTable,
ListTables,
GetDataset,
InsertDataset,
UpdateDataset,
DeleteDataset,
ListDatasets,
}
impl BigQueryFakeRpc {
pub(super) fn names_a_table(self) -> bool {
match self {
BigQueryFakeRpc::CreateReadSession
| BigQueryFakeRpc::ReadRows
| BigQueryFakeRpc::GetWriteStream
| BigQueryFakeRpc::CreateWriteStream
| BigQueryFakeRpc::AppendRows
| BigQueryFakeRpc::FlushRows
| BigQueryFakeRpc::FinalizeWriteStream
| BigQueryFakeRpc::BatchCommitWriteStreams
| BigQueryFakeRpc::GetTable
| BigQueryFakeRpc::InsertTable
| BigQueryFakeRpc::PatchTable
| BigQueryFakeRpc::UpdateTable
| BigQueryFakeRpc::DeleteTable => true,
BigQueryFakeRpc::GetQueryResults
| BigQueryFakeRpc::GetJob
| BigQueryFakeRpc::CancelJob
| BigQueryFakeRpc::ListTables
| BigQueryFakeRpc::GetDataset
| BigQueryFakeRpc::InsertDataset
| BigQueryFakeRpc::UpdateDataset
| BigQueryFakeRpc::DeleteDataset
| BigQueryFakeRpc::ListDatasets => false,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct BigQueryFakeJobFailure {
pub reason: String,
pub message: String,
}
impl BigQueryFakeJobFailure {
pub fn new(reason: impl Into<String>, message: impl Into<String>) -> Self {
Self {
reason: reason.into(),
message: message.into(),
}
}
}
pub(super) enum QueryMatcher {
Exact(String),
Matching(Box<dyn Fn(&BigQueryFakeQuery<'_>) -> bool + Send + Sync>),
}
impl QueryMatcher {
fn matches(&self, query: &BigQueryFakeQuery<'_>) -> Result<bool, String> {
match self {
QueryMatcher::Exact(expected) => Ok(expected == query.sql()),
QueryMatcher::Matching(predicate) => {
catch_unwind(AssertUnwindSafe(|| predicate(query)))
.map_err(|_| format!("a when_query matcher panicked on {:?}", query.sql()))
}
}
}
}
impl Display for QueryMatcher {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
match self {
QueryMatcher::Exact(sql) => write!(f, "query {sql:?}"),
QueryMatcher::Matching(_) => f.write_str("a when_query matcher"),
}
}
}
impl Debug for QueryMatcher {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
Display::fmt(self, f)
}
}
#[derive(Debug)]
pub(super) enum QueryAnswer {
Rows {
schema: BigQueryTableSchema,
rows: RecordBatch,
},
Dml {
statement_type: BigQueryStatementType,
stats: BigQueryDmlStats,
},
Statement(BigQueryStatementType),
Fault(BigQueryFakeFault),
JobFailure(BigQueryFakeJobFailure),
}
#[derive(Debug)]
pub(super) struct QueryReply {
pub answer: QueryAnswer,
pub bytes_processed: Option<i64>,
}
pub(super) struct QueryRule {
pub matcher: QueryMatcher,
pub parameters: Option<Vec<QueryParameter>>,
pub reply: Arc<QueryReply>,
pub rule: BigQueryFakeRule,
}
impl QueryRule {
fn matches(&self, sql: &str, parameters: &[QueryParameter]) -> Result<bool, String> {
if !self
.matcher
.matches(&BigQueryFakeQuery::new(sql, parameters))?
{
return Ok(false);
}
let Some(expected) = &self.parameters else {
return Ok(true);
};
let (expected_named, expected_positional): (Vec<_>, Vec<_>) = expected
.iter()
.partition(|parameter| !parameter.name.is_empty());
let (named, positional): (Vec<_>, Vec<_>) = parameters
.iter()
.partition(|parameter| !parameter.name.is_empty());
Ok(expected_positional == positional
&& expected_named
.iter()
.all(|parameter| named.contains(parameter))
&& named
.iter()
.all(|parameter| expected_named.contains(parameter)))
}
}
pub(super) struct ReadRule {
pub table: TableKey,
pub row_restriction: Option<String>,
pub rows: RecordBatch,
pub rule: BigQueryFakeRule,
}
pub(super) struct FaultRule {
pub rpc: BigQueryFakeRpc,
pub table: Option<TableKey>,
pub fault: BigQueryFakeFault,
pub rule: BigQueryFakeRule,
}
pub(super) type RowRejection =
Box<dyn Fn(&RecordBatch) -> BigQueryResult<Vec<usize>> + Send + Sync>;
pub(super) struct RejectRule {
pub table: TableKey,
pub reason: String,
pub rejects: RowRejection,
pub rule: BigQueryFakeRule,
}
#[derive(Default)]
pub(super) struct FakeRules {
queries: Vec<QueryRule>,
reads: Vec<ReadRule>,
faults: Vec<FaultRule>,
rejections: Vec<Arc<RejectRule>>,
}
impl FakeRules {
pub(super) fn add_query(&mut self, rule: QueryRule) {
self.queries.push(rule);
}
pub(super) fn add_read(&mut self, rule: ReadRule) {
self.reads.push(rule);
}
pub(super) fn add_fault(&mut self, rule: FaultRule) {
self.faults.push(rule);
}
pub(super) fn add_rejection(&mut self, rule: RejectRule) {
self.rejections.push(Arc::new(rule));
}
pub(super) fn answer_query(
&self,
sql: &str,
parameters: &[QueryParameter],
) -> Result<Option<Arc<QueryReply>>, String> {
for rule in &self.queries {
if rule.matches(sql, parameters)? && rule.rule.claim() {
return Ok(Some(rule.reply.clone()));
}
}
Ok(None)
}
pub(super) fn answer_read(
&self,
table: &TableKey,
row_restriction: Option<&str>,
) -> Option<RecordBatch> {
self.reads
.iter()
.find(|rule| {
rule.table == *table
&& rule.row_restriction.as_deref() == row_restriction
&& rule.rule.claim()
})
.map(|rule| rule.rows.clone())
}
pub(super) fn answer_fault(
&self,
rpc: BigQueryFakeRpc,
table: Option<&TableKey>,
) -> Option<BigQueryFakeFault> {
self.faults
.iter()
.find(|rule| {
rule.rpc == rpc
&& rule.table.as_ref().is_none_or(|only| Some(only) == table)
&& rule.rule.claim()
})
.map(|rule| rule.fault.clone())
}
pub(super) fn rejections(&self, table: &TableKey) -> Vec<Arc<RejectRule>> {
self.rejections
.iter()
.filter(|rule| rule.table == *table)
.cloned()
.collect()
}
pub(super) fn describe_queries(&self) -> Vec<String> {
Self::describe(self.queries.iter().map(|rule| &rule.rule))
}
pub(super) fn describe_reads(&self) -> Vec<String> {
Self::describe(self.reads.iter().map(|rule| &rule.rule))
}
fn describe<'r>(rules: impl Iterator<Item = &'r BigQueryFakeRule>) -> Vec<String> {
rules.map(BigQueryFakeRule::listed).collect()
}
pub(super) fn shortfalls(&self) -> Vec<String> {
let queries = self.queries.iter().map(|rule| &rule.rule);
let reads = self.reads.iter().map(|rule| &rule.rule);
let faults = self.faults.iter().map(|rule| &rule.rule);
queries
.chain(reads)
.chain(faults)
.filter_map(BigQueryFakeRule::shortfall)
.collect()
}
}
pub(super) struct ShownParameters<'p>(pub &'p [QueryParameter]);
impl Display for ShownParameters<'_> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
if self.0.is_empty() {
return f.write_str("no parameters");
}
for (index, parameter) in self.0.iter().enumerate() {
if index > 0 {
f.write_str(", ")?;
}
if parameter.name.is_empty() {
write!(f, "?{} = ", index + 1)?;
} else {
write!(f, "@{} = ", parameter.name)?;
}
match ¶meter.parameter_value {
Some(value) => ShownValue(value).fmt(f)?,
None => f.write_str("NULL")?,
}
}
Ok(())
}
}
struct ShownValue<'v>(&'v QueryParameterValue);
impl Display for ShownValue<'_> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
let value = self.0;
if let Some(scalar) = &value.value {
return write!(f, "{scalar:?}");
}
if !value.array_values.is_empty() {
f.write_str("[")?;
for (index, element) in value.array_values.iter().enumerate() {
if index > 0 {
f.write_str(", ")?;
}
ShownValue(element).fmt(f)?;
}
return f.write_str("]");
}
if !value.struct_values.is_empty() {
let mut fields: Vec<_> = value.struct_values.iter().collect();
fields.sort_by_key(|(name, _)| *name);
f.write_str("{")?;
for (index, (name, field)) in fields.into_iter().enumerate() {
if index > 0 {
f.write_str(", ")?;
}
write!(f, "{name}: ")?;
ShownValue(field).fmt(f)?;
}
return f.write_str("}");
}
if let Some(range) = &value.range_value {
let bound = |bound: &Option<Box<QueryParameterValue>>| {
bound.as_deref().map_or_else(
|| "UNBOUNDED".to_string(),
|bound| ShownValue(bound).to_string(),
)
};
return write!(f, "[{}, {})", bound(&range.start), bound(&range.end));
}
f.write_str("NULL")
}
}