getdozer/dozer | Build 5640948961 | dozer-sql/src/pipeline/expression/tests/mathematical.rs | Coveralls

18

#[test]

1✔

19

fn test_uint_math() {

1✔

20

    proptest!(ProptestConfig::with_cases(1000), move |(u_num1: u64, u_num2: u64, u128_num1: u128, u128_num2: u128, i_num1: i64, i_num2: i64, i128_num1: i128, i128_num2: i128, f_num1: f64, f_num2: f64, d_num1: ArbitraryDecimal, d_num2: ArbitraryDecimal)| {

1,000✔

21

        let row = Record::new(vec![]);

1,000✔

22

1,000✔

23

        let uint1 = Box::new(Literal(Field::UInt(u_num1)));

1,000✔

24

        let uint2 = Box::new(Literal(Field::UInt(u_num2)));

1,000✔

25

        let u128_1 = Box::new(Literal(Field::U128(u128_num1)));

1,000✔

26

        let u128_2 = Box::new(Literal(Field::U128(u128_num2)));

1,000✔

27

        let int1 = Box::new(Literal(Field::Int(i_num1)));

1,000✔

28

        let int2 = Box::new(Literal(Field::Int(i_num2)));

1,000✔

29

        let i128_1 = Box::new(Literal(Field::I128(i128_num1)));

1,000✔

30

        let i128_2 = Box::new(Literal(Field::I128(i128_num2)));

1,000✔

31

        let float1 = Box::new(Literal(Field::Float(OrderedFloat(f_num1))));

1,000✔

32

        let float2 = Box::new(Literal(Field::Float(OrderedFloat(f_num2))));

1,000✔

33

        let dec1 = Box::new(Literal(Field::Decimal(d_num1.0)));

1,000✔

34

        let dec2 = Box::new(Literal(Field::Decimal(d_num2.0)));

1,000✔

35

1,000✔

36

        let null = Box::new(Literal(Field::Null));

1,000✔

37

1,000✔

38

        //// left: UInt, right: UInt

1,000✔

39

        assert_eq!(

1,000✔

40

            // UInt + UInt = UInt

1,000✔

41

            evaluate_add(&Schema::default(), &uint1, &uint2, &row)

1,000✔

42

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

43

            Field::UInt((Wrapping(u_num1) + Wrapping(u_num2)).0)

1,000✔

44

);

1,000✔

45

        assert_eq!(

1,000✔

46

            // UInt - UInt = UInt

1,000✔

47

            evaluate_sub(&Schema::default(), &uint1, &uint2, &row)

1,000✔

48

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

49

            Field::UInt((Wrapping(u_num1) - Wrapping(u_num2)).0)

1,000✔

50

);

1,000✔

51

        assert_eq!(

1,000✔

52

            // UInt * UInt = UInt

1,000✔

53

            evaluate_mul(&Schema::default(), &uint2, &uint1, &row)

1,000✔

54

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

55

            Field::UInt((Wrapping(u_num2) * Wrapping(u_num1)).0)

1,000✔

56

);

1,000✔

57

        assert_eq!(

1,000✔

58

            // UInt / UInt = Float

1,000✔

59

            evaluate_div(&Schema::default(), &uint2, &uint1, &row)

1,000✔

60

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

61

            Field::Float(OrderedFloat(f64::from_u64(u_num2).unwrap() / f64::from_u64(u_num1).unwrap()))

1,000✔

62

);

1,000✔

63

        assert_eq!(

1,000✔

64

            // UInt % UInt = UInt

1,000✔

65

            evaluate_mod(&Schema::default(), &uint1, &uint2, &row)

1,000✔

66

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

67

            Field::UInt((Wrapping(u_num1) % Wrapping(u_num2)).0)

1,000✔

68

);

1,000✔

69

1,000✔

70

        //// left: UInt, right: U128

1,000✔

71

        assert_eq!(

1,000✔

72

            // UInt + U128 = U128

1,000✔

73

            evaluate_add(&Schema::default(), &uint1, &u128_2, &row)

1,000✔

74

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

75

            Field::U128((Wrapping(u_num1 as u128) + Wrapping(u128_num2)).0)

1,000✔

76

);

1,000✔

77

        assert_eq!(

1,000✔

78

            // UInt - U128 = U128

1,000✔

79

            evaluate_sub(&Schema::default(), &uint1, &u128_2, &row)

1,000✔

80

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

81

            Field::U128((Wrapping(u_num1 as u128) - Wrapping(u128_num2)).0)

1,000✔

82

);

1,000✔

83

        assert_eq!(

1,000✔

84

            // UInt * U128 = U128

1,000✔

85

            evaluate_mul(&Schema::default(), &uint2, &u128_1, &row)

1,000✔

86

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

87

            Field::U128((Wrapping(u_num2 as u128) * Wrapping(u128_num1)).0)

1,000✔

88

);

1,000✔

89

        assert_eq!(

1,000✔

90

            // UInt / U128 = Float

1,000✔

91

            evaluate_div(&Schema::default(), &uint2, &u128_1, &row)

1,000✔

92

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

93

            Field::Float(OrderedFloat(f64::from_u64(u_num2).unwrap() / f64::from_u128(u128_num1).unwrap()))

1,000✔

94

);

1,000✔

95

        assert_eq!(

1,000✔

96

            // UInt % U128 = U128

1,000✔

97

            evaluate_mod(&Schema::default(), &uint1, &u128_2, &row)

1,000✔

98

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

99

            Field::U128((Wrapping(u_num1 as u128) % Wrapping(u128_num2)).0)

1,000✔

100

);

1,000✔

101

1,000✔

102

        //// left: UInt, right: Int

1,000✔

103

        assert_eq!(

1,000✔

104

            // UInt + Int = Int

1,000✔

105

            evaluate_add(&Schema::default(), &uint1, &int2, &row)

1,000✔

106

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

107

            Field::Int((Wrapping(u_num1 as i64) + Wrapping(i_num2)).0)

1,000✔

108

);

1,000✔

109

        assert_eq!(

1,000✔

110

            // UInt - Int = Int

1,000✔

111

            evaluate_sub(&Schema::default(), &uint1, &int2, &row)

1,000✔

112

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

113

            Field::Int((Wrapping(u_num1 as i64) - Wrapping(i_num2)).0)

1,000✔

114

);

1,000✔

115

        assert_eq!(

1,000✔

116

            // UInt * Int = Int

1,000✔

117

            evaluate_mul(&Schema::default(), &uint2, &int1, &row)

1,000✔

118

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

119

            Field::Int((Wrapping(u_num2 as i64) * Wrapping(i_num1)).0)

1,000✔

120

);

1,000✔

121

        assert_eq!(

1,000✔

122

            // UInt / Int = Float

1,000✔

123

            evaluate_div(&Schema::default(), &uint2, &int1, &row)

1,000✔

124

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

125

            Field::Float(OrderedFloat(f64::from_u64(u_num2).unwrap() / f64::from_i64(i_num1).unwrap()))

1,000✔

126

);

1,000✔

127

        assert_eq!(

1,000✔

128

            // UInt % Int = Int

1,000✔

129

            evaluate_mod(&Schema::default(), &uint1, &int2, &row)

1,000✔

130

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

131

            Field::Int((Wrapping(u_num1 as i64) % Wrapping(i_num2)).0)

1,000✔

132

);

1,000✔

133

1,000✔

134

        //// left: UInt, right: I128

1,000✔

135

        assert_eq!(

1,000✔

136

            // UInt + I128 = I128

1,000✔

137

            evaluate_add(&Schema::default(), &uint1, &i128_2, &row)

1,000✔

138

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

139

            Field::I128((Wrapping(u_num1 as i128) + Wrapping(i128_num2)).0)

1,000✔

140

);

1,000✔

141

        assert_eq!(

1,000✔

142

            // UInt - I128 = I128

1,000✔

143

            evaluate_sub(&Schema::default(), &uint1, &i128_2, &row)

1,000✔

144

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

145

            Field::I128((Wrapping(u_num1 as i128) - Wrapping(i128_num2)).0)

1,000✔

146

);

1,000✔

147

        assert_eq!(

1,000✔

148

            // UInt * I128 = I128

1,000✔

149

            evaluate_mul(&Schema::default(), &uint2, &i128_1, &row)

1,000✔

150

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

151

            Field::I128((Wrapping(u_num2 as i128) * Wrapping(i128_num1)).0)

1,000✔

152

);

1,000✔

153

        assert_eq!(

1,000✔

154

            // UInt / I128 = Float

1,000✔

155

            evaluate_div(&Schema::default(), &uint2, &i128_1, &row)

1,000✔

156

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

157

            Field::Float(OrderedFloat(f64::from_u64(u_num2).unwrap() / f64::from_i128(i128_num1).unwrap()))

1,000✔

158

);

1,000✔

159

        assert_eq!(

1,000✔

160

            // UInt % I128 = I128

1,000✔

161

            evaluate_mod(&Schema::default(), &uint1, &i128_2, &row)

1,000✔

162

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

163

            Field::I128((Wrapping(u_num1 as i128) % Wrapping(i128_num2)).0)

1,000✔

164

);

1,000✔

165

1,000✔

166

        //// left: UInt, right: Float

1,000✔

167

        assert_eq!(

1,000✔

168

            // UInt + Float = Float

1,000✔

169

            evaluate_add(&Schema::default(), &uint1, &float2, &row)

1,000✔

170

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

171

            Field::Float(OrderedFloat(f64::from_u64(u_num1).unwrap() + f_num2))

1,000✔

172

);

1,000✔

173

        assert_eq!(

1,000✔

174

            // UInt - Float = Float

1,000✔

175

            evaluate_sub(&Schema::default(), &uint1, &float2, &row)

1,000✔

176

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

177

            Field::Float(OrderedFloat(f64::from_u64(u_num1).unwrap() - f_num2))

1,000✔

178

);

1,000✔

179

        assert_eq!(

1,000✔

180

            // UInt * Float = Float

1,000✔

181

            evaluate_mul(&Schema::default(), &uint2, &float1, &row)

1,000✔

182

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

183

            Field::Float(OrderedFloat(f64::from_u64(u_num2).unwrap() * f_num1))

1,000✔

184

);

1,000✔

185

        if *float1 != Literal(Field::Float(OrderedFloat(0_f64))) {

1,000✔

186

            assert_eq!(

1,000✔

187

                // UInt / Float = Float

849✔

188

                evaluate_div(&Schema::default(), &uint2, &float1, &row)

849✔

189

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

849✔

190

                Field::Float(OrderedFloat(f64::from_u64(u_num2).unwrap() / f_num1))

849✔

191

);

849✔

192

1,000✔

193

        if *float2 != Literal(Field::Float(OrderedFloat(0_f64))) {

1,000✔

194

            assert_eq!(

1,000✔

195

                // UInt % Float = Float

837✔

196

                evaluate_mod(&Schema::default(), &uint1, &float2, &row)

837✔

197

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

837✔

198

                Field::Float(OrderedFloat(f64::from_u64(u_num1).unwrap() % f_num2))

837✔

199

);

837✔

200

1,000✔

201

1,000✔

202

        //// left: UInt, right: Decimal

1,000✔

203

        assert_eq!(

1,000✔

204

            // UInt + Decimal = Decimal

1,000✔

205

            evaluate_add(&Schema::default(), &uint1, &dec2, &row)

1,000✔

206

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

207

            Field::Decimal(Decimal::from_u64(u_num1).unwrap() + d_num2.0)

1,000✔

208

);

1,000✔

209

        assert_eq!(

1,000✔

210

            // UInt - Decimal = Decimal

1,000✔

211

            evaluate_sub(&Schema::default(), &uint1, &dec2, &row)

1,000✔

212

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

213

            Field::Decimal(Decimal::from_u64(u_num1).unwrap() - d_num2.0)

1,000✔

214

);

1,000✔

215

        // UInt * Decimal = Decimal

1,000✔

216

        let res = evaluate_mul(&Schema::default(), &uint2, &dec1, &row);

1,000✔

217

        if res.is_ok() {

1,000✔

218

             assert_eq!(

1,000✔

219

                res.unwrap(), Field::Decimal(Decimal::from_u64(u_num2).unwrap().checked_mul(d_num1.0).unwrap())

684✔

220

);

684✔

221

        } else {

1,000✔

222

            assert!(res.is_err());

1,000✔

223

            assert!(matches!(

1,000✔

224

                res,

1,000✔

225

                Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

226

));

1,000✔

227

1,000✔

228

        // UInt / Decimal = Decimal

1,000✔

229

        let res = evaluate_div(&Schema::default(), &uint2, &dec1, &row);

1,000✔

230

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

231

            assert!(res.is_err());

1,000✔

232

            assert!(matches!(

1,000✔

233

                res,

1,000✔

234

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

235

));

1,000✔

236

1,000✔

237

        else if res.is_ok() {

1,000✔

238

             assert_eq!(

1,000✔

239

                res.unwrap(), Field::Decimal(Decimal::from_u64(u_num2).unwrap() / d_num1.0)

997✔

240

);

997✔

241

        } else {

1,000✔

242

            assert!(res.is_err());

1,000✔

243

            assert!(matches!(

1,000✔

244

                res,

1,000✔

245

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

246

));

1,000✔

247

1,000✔

248

        // UInt % Decimal = Decimal

1,000✔

249

        let res = evaluate_mod(&Schema::default(), &uint2, &dec1, &row);

1,000✔

250

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

251

            assert!(res.is_err());

1,000✔

252

            assert!(matches!(

1,000✔

253

                res,

1,000✔

254

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

255

));

1,000✔

256

1,000✔

257

        else if res.is_ok() {

1,000✔

258

             assert_eq!(

1,000✔

259

                res.unwrap(), Field::Decimal(Decimal::from_u64(u_num2).unwrap() % d_num1.0)

1,000✔

260

);

1,000✔

261

        } else {

1,000✔

262

            assert!(res.is_err());

1,000✔

263

            assert!(matches!(

1,000✔

264

                res,

1,000✔

265

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

266

));

1,000✔

267

1,000✔

268

1,000✔

269

        //// left: UInt, right: Null

1,000✔

270

        assert_eq!(

1,000✔

271

            // UInt + Null = Null

1,000✔

272

            evaluate_add(&Schema::default(), &uint1, &null, &row)

1,000✔

273

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

274

            Field::Null

1,000✔

275

);

1,000✔

276

        assert_eq!(

1,000✔

277

            // UInt - Null = Null

1,000✔

278

            evaluate_sub(&Schema::default(), &uint1, &null, &row)

1,000✔

279

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

280

            Field::Null

1,000✔

281

);

1,000✔

282

        assert_eq!(

1,000✔

283

            // UInt * Null = Null

1,000✔

284

            evaluate_mul(&Schema::default(), &uint2, &null, &row)

1,000✔

285

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

286

            Field::Null

1,000✔

287

);

1,000✔

288

        assert_eq!(

1,000✔

289

            // UInt / Null = Null

1,000✔

290

            evaluate_div(&Schema::default(), &uint2, &null, &row)

1,000✔

291

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

292

            Field::Null

1,000✔

293

);

1,000✔

294

        assert_eq!(

1,000✔

295

            // UInt % Null = Null

1,000✔

296

            evaluate_mod(&Schema::default(), &uint1, &null, &row)

1,000✔

297

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

298

            Field::Null

1,000✔

299

);

1,000✔

300

});

1,000✔

301

1✔

303

#[test]

1✔

304

fn test_u128_math() {

1✔

305

    proptest!(ProptestConfig::with_cases(1000), move |(u_num1: u64, u_num2: u64, u128_num1: u128, u128_num2: u128, i_num1: i64, i_num2: i64, i128_num1: i128, i128_num2: i128, f_num1: f64, f_num2: f64, d_num1: ArbitraryDecimal, d_num2: ArbitraryDecimal)| {

1,000✔

306

        let row = Record::new(vec![]);

1,000✔

307

1,000✔

308

        let uint1 = Box::new(Literal(Field::UInt(u_num1)));

1,000✔

309

        let uint2 = Box::new(Literal(Field::UInt(u_num2)));

1,000✔

310

        let u128_1 = Box::new(Literal(Field::U128(u128_num1)));

1,000✔

311

        let u128_2 = Box::new(Literal(Field::U128(u128_num2)));

1,000✔

312

        let int1 = Box::new(Literal(Field::Int(i_num1)));

1,000✔

313

        let int2 = Box::new(Literal(Field::Int(i_num2)));

1,000✔

314

        let i128_1 = Box::new(Literal(Field::I128(i128_num1)));

1,000✔

315

        let i128_2 = Box::new(Literal(Field::I128(i128_num2)));

1,000✔

316

        let float1 = Box::new(Literal(Field::Float(OrderedFloat(f_num1))));

1,000✔

317

        let float2 = Box::new(Literal(Field::Float(OrderedFloat(f_num2))));

1,000✔

318

        let dec1 = Box::new(Literal(Field::Decimal(d_num1.0)));

1,000✔

319

        let dec2 = Box::new(Literal(Field::Decimal(d_num2.0)));

1,000✔

320

1,000✔

321

        let null = Box::new(Literal(Field::Null));

1,000✔

322

1,000✔

323

        //// left: U128, right: UInt

1,000✔

324

        assert_eq!(

1,000✔

325

            // U128 + UInt = U128

1,000✔

326

            evaluate_add(&Schema::default(), &u128_1, &uint2, &row)

1,000✔

327

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

328

            Field::U128((Wrapping(u128_num1) + Wrapping(u_num2 as u128)).0)

1,000✔

329

);

1,000✔

330

        assert_eq!(

1,000✔

331

            // U128 - UInt = U128

1,000✔

332

            evaluate_sub(&Schema::default(), &u128_1, &uint2, &row)

1,000✔

333

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

334

            Field::U128((Wrapping(u128_num1) - Wrapping(u_num2 as u128)).0)

1,000✔

335

);

1,000✔

336

        assert_eq!(

1,000✔

337

            // U128 * UInt = U128

1,000✔

338

            evaluate_mul(&Schema::default(), &u128_2, &uint1, &row)

1,000✔

339

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

340

            Field::U128((Wrapping(u128_num2) * Wrapping(u_num1 as u128)).0)

1,000✔

341

);

1,000✔

342

        assert_eq!(

1,000✔

343

            // U128 / UInt = Float

1,000✔

344

            evaluate_div(&Schema::default(), &u128_2, &uint1, &row)

1,000✔

345

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

346

            Field::Float(OrderedFloat(f64::from_u128(u128_num2).unwrap() / f64::from_u64(u_num1).unwrap()))

1,000✔

347

);

1,000✔

348

        assert_eq!(

1,000✔

349

            // U128 % UInt = U128

1,000✔

350

            evaluate_mod(&Schema::default(), &u128_1, &uint2, &row)

1,000✔

351

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

352

            Field::U128((Wrapping(u128_num1) % Wrapping(u_num2 as u128)).0)

1,000✔

353

);

1,000✔

354

1,000✔

355

        //// left: U128, right: U128

1,000✔

356

        assert_eq!(

1,000✔

357

            // U128 + U128 = U128

1,000✔

358

            evaluate_add(&Schema::default(), &u128_1, &u128_2, &row)

1,000✔

359

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

360

            Field::U128((Wrapping(u128_num1) + Wrapping(u128_num2)).0)

1,000✔

361

);

1,000✔

362

        assert_eq!(

1,000✔

363

            // U128 - U128 = U128

1,000✔

364

            evaluate_sub(&Schema::default(), &u128_1, &u128_2, &row)

1,000✔

365

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

366

            Field::U128((Wrapping(u128_num1) - Wrapping(u128_num2)).0)

1,000✔

367

);

1,000✔

368

        assert_eq!(

1,000✔

369

            // U128 * U128 = U128

1,000✔

370

            evaluate_mul(&Schema::default(), &u128_2, &u128_1, &row)

1,000✔

371

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

372

            Field::U128((Wrapping(u128_num2) * Wrapping(u128_num1)).0)

1,000✔

373

);

1,000✔

374

        assert_eq!(

1,000✔

375

            // U128 / U128 = Float

1,000✔

376

            evaluate_div(&Schema::default(), &u128_2, &u128_1, &row)

1,000✔

377

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

378

            Field::Float(OrderedFloat(f64::from_u128(u128_num2).unwrap() / f64::from_u128(u128_num1).unwrap()))

1,000✔

379

);

1,000✔

380

        assert_eq!(

1,000✔

381

            // U128 % U128 = U128

1,000✔

382

            evaluate_mod(&Schema::default(), &u128_1, &u128_2, &row)

1,000✔

383

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

384

            Field::U128((Wrapping(u128_num1) % Wrapping(u128_num2)).0)

1,000✔

385

);

1,000✔

386

1,000✔

387

        //// left: U128, right: Int

1,000✔

388

        assert_eq!(

1,000✔

389

            // U128 + Int = I128

1,000✔

390

            evaluate_add(&Schema::default(), &u128_1, &int2, &row)

1,000✔

391

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

392

            Field::I128((Wrapping(u128_num1 as i128) + Wrapping(i_num2 as i128)).0)

1,000✔

393

);

1,000✔

394

        assert_eq!(

1,000✔

395

            // U128 - Int = I128

1,000✔

396

            evaluate_sub(&Schema::default(), &u128_1, &int2, &row)

1,000✔

397

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

398

            Field::I128((Wrapping(u128_num1 as i128) - Wrapping(i_num2 as i128)).0)

1,000✔

399

);

1,000✔

400

        assert_eq!(

1,000✔

401

            // U128 * Int = I128

1,000✔

402

            evaluate_mul(&Schema::default(), &u128_2, &int1, &row)

1,000✔

403

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

404

            Field::I128((Wrapping(u128_num2 as i128) * Wrapping(i_num1 as i128)).0)

1,000✔

405

);

1,000✔

406

        assert_eq!(

1,000✔

407

            // U128 / Int = Float

1,000✔

408

            evaluate_div(&Schema::default(), &u128_2, &int1, &row)

1,000✔

409

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

410

            Field::Float(OrderedFloat(f64::from_u128(u128_num2).unwrap() / f64::from_i64(i_num1).unwrap()))

1,000✔

411

);

1,000✔

412

        assert_eq!(

1,000✔

413

            // U128 % Int = I128

1,000✔

414

            evaluate_mod(&Schema::default(), &u128_1, &int2, &row)

1,000✔

415

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

416

            Field::I128((Wrapping(u128_num1 as i128) % Wrapping(i_num2 as i128)).0)

1,000✔

417

);

1,000✔

418

1,000✔

419

        //// left: U128, right: I128

1,000✔

420

        assert_eq!(

1,000✔

421

            // U128 + I128 = I128

1,000✔

422

            evaluate_add(&Schema::default(), &u128_1, &i128_2, &row)

1,000✔

423

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

424

            Field::I128((Wrapping(u128_num1 as i128) + Wrapping(i128_num2)).0)

1,000✔

425

);

1,000✔

426

        assert_eq!(

1,000✔

427

            // U128 - I128 = I128

1,000✔

428

            evaluate_sub(&Schema::default(), &u128_1, &i128_2, &row)

1,000✔

429

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

430

            Field::I128((Wrapping(u128_num1 as i128) - Wrapping(i128_num2)).0)

1,000✔

431

);

1,000✔

432

        assert_eq!(

1,000✔

433

            // U128 * I128 = I128

1,000✔

434

            evaluate_mul(&Schema::default(), &u128_2, &i128_1, &row)

1,000✔

435

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

436

            Field::I128((Wrapping(u128_num2 as i128) * Wrapping(i128_num1)).0)

1,000✔

437

);

1,000✔

438

        assert_eq!(

1,000✔

439

            // U128 / I128 = Float

1,000✔

440

            evaluate_div(&Schema::default(), &u128_2, &i128_1, &row)

1,000✔

441

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

442

            Field::Float(OrderedFloat(f64::from_u128(u128_num2).unwrap() / f64::from_i128(i128_num1).unwrap()))

1,000✔

443

);

1,000✔

444

        assert_eq!(

1,000✔

445

            // U128 % I128 = I128

1,000✔

446

            evaluate_mod(&Schema::default(), &u128_1, &i128_2, &row)

1,000✔

447

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

448

            Field::I128((Wrapping(u128_num1 as i128) % Wrapping(i128_num2)).0)

1,000✔

449

);

1,000✔

450

1,000✔

451

        //// left: U128, right: Float

1,000✔

452

        let res = evaluate_add(&Schema::default(), &u128_1, &float2, &row);

1,000✔

453

        if res.is_ok() {

1,000✔

454

            assert_eq!(

1,000✔

460

1,000✔

461

        let res = evaluate_sub(&Schema::default(), &u128_1, &float2, &row);

1,000✔

462

        if res.is_ok() {

1,000✔

463

            assert_eq!(

1,000✔

469

1,000✔

470

        let res = evaluate_mul(&Schema::default(), &u128_2, &float1, &row);

1,000✔

471

        if res.is_ok() {

1,000✔

472

            assert_eq!(

1,000✔

478

1,000✔

479

        let res = evaluate_div(&Schema::default(), &u128_2, &float1, &row);

1,000✔

480

        if res.is_ok() {

1,000✔

481

            assert_eq!(

1,000✔

487

1,000✔

488

        let res = evaluate_mod(&Schema::default(), &u128_1, &float2, &row);

1,000✔

489

        if res.is_ok() {

1,000✔

490

            assert_eq!(

1,000✔

496

1,000✔

497

1,000✔

498

        //// left: U128, right: Decimal

1,000✔

499

        let res = evaluate_add(&Schema::default(), &u128_1, &dec2, &row);

1,000✔

500

        if res.is_ok() {

1,000✔

501

            assert_eq!(

1,000✔

507

1,000✔

508

        let res = evaluate_sub(&Schema::default(), &u128_1, &dec2, &row);

1,000✔

509

        if res.is_ok() {

1,000✔

510

            assert_eq!(

1,000✔

516

1,000✔

517

        // U128 * Decimal = Decimal

1,000✔

518

        let res = evaluate_mul(&Schema::default(), &u128_2, &dec1, &row);

1,000✔

519

        if res.is_ok() {

1,000✔

520

             assert_eq!(

1,000✔

523

        } else {

1,000✔

524

            assert!(res.is_err());

1,000✔

525

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

526

                assert!(matches!(

1,000✔

527

                    res,

1,000✔

528

                    Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

529

));

1,000✔

530

1,000✔

531

1,000✔

532

        // U128 / Decimal = Decimal

1,000✔

533

        let res = evaluate_div(&Schema::default(), &u128_2, &dec1, &row);

1,000✔

534

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

535

            assert!(res.is_err());

1,000✔

536

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

537

                assert!(matches!(

1,000✔

538

                    res,

1,000✔

539

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

540

));

1,000✔

541

1,000✔

542

1,000✔

543

        else if res.is_ok() {

1,000✔

544

             assert_eq!(

1,000✔

547

        } else {

1,000✔

548

            assert!(res.is_err());

1,000✔

549

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

550

                assert!(matches!(

1,000✔

551

                    res,

1,000✔

552

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

553

));

1,000✔

554

1,000✔

555

1,000✔

556

        // U128 % Decimal = Decimal

1,000✔

557

        let res = evaluate_mod(&Schema::default(), &u128_1, &dec1, &row);

1,000✔

558

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

559

            assert!(res.is_err());

1,000✔

560

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

561

                assert!(matches!(

1,000✔

562

                    res,

1,000✔

563

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

564

));

1,000✔

565

1,000✔

566

1,000✔

567

        else if res.is_ok() {

1,000✔

568

             assert_eq!(

1,000✔

571

        } else {

1,000✔

572

            assert!(res.is_err());

1,000✔

573

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

574

                assert!(matches!(

1,000✔

575

                    res,

1,000✔

576

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

577

));

1,000✔

578

1,000✔

579

1,000✔

580

1,000✔

581

        //// left: U128, right: Null

1,000✔

582

        assert_eq!(

1,000✔

583

            // U128 + Null = Null

1,000✔

584

            evaluate_add(&Schema::default(), &u128_1, &null, &row)

1,000✔

585

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

586

            Field::Null

1,000✔

587

);

1,000✔

588

        assert_eq!(

1,000✔

589

            // U128 - Null = Null

1,000✔

590

            evaluate_sub(&Schema::default(), &u128_1, &null, &row)

1,000✔

591

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

592

            Field::Null

1,000✔

593

);

1,000✔

594

        assert_eq!(

1,000✔

595

            // U128 * Null = Null

1,000✔

596

            evaluate_mul(&Schema::default(), &u128_2, &null, &row)

1,000✔

597

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

598

            Field::Null

1,000✔

599

);

1,000✔

600

        assert_eq!(

1,000✔

601

            // U128 / Null = Null

1,000✔

602

            evaluate_div(&Schema::default(), &u128_2, &null, &row)

1,000✔

603

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

604

            Field::Null

1,000✔

605

);

1,000✔

606

        assert_eq!(

1,000✔

607

            // U128 % Null = Null

1,000✔

608

            evaluate_mod(&Schema::default(), &u128_1, &null, &row)

1,000✔

609

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

610

            Field::Null

1,000✔

611

);

1,000✔

612

});

1,000✔

613

1✔

615

#[test]

1✔

616

fn test_int_math() {

1✔

617

    proptest!(ProptestConfig::with_cases(1000), move |(u_num1: u64, u_num2: u64, u128_num1: u128, u128_num2: u128, i_num1: i64, i_num2: i64, i128_num1: i128, i128_num2: i128, f_num1: f64, f_num2: f64, d_num1: ArbitraryDecimal, d_num2: ArbitraryDecimal)| {

1,000✔

618

        let row = Record::new(vec![]);

1,000✔

619

1,000✔

620

        let uint1 = Box::new(Literal(Field::UInt(u_num1)));

1,000✔

621

        let uint2 = Box::new(Literal(Field::UInt(u_num2)));

1,000✔

622

        let u128_1 = Box::new(Literal(Field::U128(u128_num1)));

1,000✔

623

        let u128_2 = Box::new(Literal(Field::U128(u128_num2)));

1,000✔

624

        let int1 = Box::new(Literal(Field::Int(i_num1)));

1,000✔

625

        let int2 = Box::new(Literal(Field::Int(i_num2)));

1,000✔

626

        let i128_1 = Box::new(Literal(Field::I128(i128_num1)));

1,000✔

627

        let i128_2 = Box::new(Literal(Field::I128(i128_num2)));

1,000✔

628

        let float1 = Box::new(Literal(Field::Float(OrderedFloat(f_num1))));

1,000✔

629

        let float2 = Box::new(Literal(Field::Float(OrderedFloat(f_num2))));

1,000✔

630

        let dec1 = Box::new(Literal(Field::Decimal(d_num1.0)));

1,000✔

631

        let dec2 = Box::new(Literal(Field::Decimal(d_num2.0)));

1,000✔

632

1,000✔

633

        let null = Box::new(Literal(Field::Null));

1,000✔

634

1,000✔

635

        //// left: Int, right: UInt

1,000✔

636

        assert_eq!(

1,000✔

637

            // Int + UInt = Int

1,000✔

638

            evaluate_add(&Schema::default(), &int1, &uint2, &row)

1,000✔

639

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

640

            Field::Int((Wrapping(i_num1) + Wrapping(u_num2 as i64)).0)

1,000✔

641

);

1,000✔

642

        assert_eq!(

1,000✔

643

            // Int - UInt = Int

1,000✔

644

            evaluate_sub(&Schema::default(), &int1, &uint2, &row)

1,000✔

645

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

646

            Field::Int((Wrapping(i_num1) - Wrapping(u_num2 as i64)).0)

1,000✔

647

);

1,000✔

648

        assert_eq!(

1,000✔

649

            // Int * UInt = Int

1,000✔

650

            evaluate_mul(&Schema::default(), &int2, &uint1, &row)

1,000✔

651

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

652

            Field::Int((Wrapping(i_num2) * Wrapping(u_num1 as i64)).0)

1,000✔

653

);

1,000✔

654

        assert_eq!(

1,000✔

655

            // Int / UInt = Float

1,000✔

656

            evaluate_div(&Schema::default(), &int2, &uint1, &row)

1,000✔

657

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

658

            Field::Float(OrderedFloat(f64::from_i64(i_num2).unwrap() / f64::from_u64(u_num1).unwrap()))

1,000✔

659

);

1,000✔

660

        assert_eq!(

1,000✔

661

            // Int % UInt = Int

1,000✔

662

            evaluate_mod(&Schema::default(), &int1, &uint2, &row)

1,000✔

663

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

664

            Field::Int((Wrapping(i_num1) % Wrapping(u_num2 as i64)).0)

1,000✔

665

);

1,000✔

666

1,000✔

667

        //// left: Int, right: U128

1,000✔

668

        assert_eq!(

1,000✔

669

            // Int + U128 = I128

1,000✔

670

            evaluate_add(&Schema::default(), &int1, &u128_2, &row)

1,000✔

671

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

672

            Field::I128((Wrapping(i_num1 as i128) + Wrapping(u128_num2 as i128)).0)

1,000✔

673

);

1,000✔

674

        assert_eq!(

1,000✔

675

            // Int - U128 = I128

1,000✔

676

            evaluate_sub(&Schema::default(), &int1, &u128_2, &row)

1,000✔

677

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

678

            Field::I128((Wrapping(i_num1 as i128) - Wrapping(u128_num2 as i128)).0)

1,000✔

679

);

1,000✔

680

        assert_eq!(

1,000✔

681

            // Int * U128 = I128

1,000✔

682

            evaluate_mul(&Schema::default(), &int2, &u128_1, &row)

1,000✔

683

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

684

            Field::I128((Wrapping(i_num2 as i128) * Wrapping(u128_num1 as i128)).0)

1,000✔

685

);

1,000✔

686

        let res = evaluate_div(&Schema::default(), &int2, &u128_1, &row);

1,000✔

687

        if res.is_ok() {

1,000✔

688

            assert_eq!(

1,000✔

693

1,000✔

694

        assert_eq!(

1,000✔

695

            // Int % U128 = I128

1,000✔

696

            evaluate_mod(&Schema::default(), &int1, &u128_2, &row)

1,000✔

697

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

698

            Field::I128((Wrapping(i_num1 as i128) % Wrapping(u128_num2 as i128)).0)

1,000✔

699

);

1,000✔

700

1,000✔

701

        //// left: Int, right: Int

1,000✔

702

        assert_eq!(

1,000✔

703

            // Int + Int = Int

1,000✔

704

            evaluate_add(&Schema::default(), &int1, &int2, &row)

1,000✔

705

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

706

            Field::Int((Wrapping(i_num1) + Wrapping(i_num2)).0)

1,000✔

707

);

1,000✔

708

        assert_eq!(

1,000✔

709

            // Int - Int = Int

1,000✔

710

            evaluate_sub(&Schema::default(), &int1, &int2, &row)

1,000✔

711

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

712

            Field::Int((Wrapping(i_num1) - Wrapping(i_num2)).0)

1,000✔

713

);

1,000✔

714

        assert_eq!(

1,000✔

715

            // Int * Int = Int

1,000✔

716

            evaluate_mul(&Schema::default(), &int2, &int1, &row)

1,000✔

717

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

718

            Field::Int((Wrapping(i_num2) * Wrapping(i_num1)).0)

1,000✔

719

);

1,000✔

720

        assert_eq!(

1,000✔

721

            // Int / Int = Float

1,000✔

722

            evaluate_div(&Schema::default(), &int2, &int1, &row)

1,000✔

723

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

724

            Field::Float(OrderedFloat(f64::from_i64(i_num2).unwrap() / f64::from_i64(i_num1).unwrap()))

1,000✔

725

);

1,000✔

726

        assert_eq!(

1,000✔

727

            // Int % Int = Int

1,000✔

728

            evaluate_mod(&Schema::default(), &int1, &int2, &row)

1,000✔

729

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

730

            Field::Int((Wrapping(i_num1) % Wrapping(i_num2)).0)

1,000✔

731

);

1,000✔

732

1,000✔

733

        //// left: Int, right: I128

1,000✔

734

        assert_eq!(

1,000✔

735

            // Int + I128 = I128

1,000✔

736

            evaluate_add(&Schema::default(), &int1, &i128_2, &row)

1,000✔

737

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

738

            Field::I128((Wrapping(i_num1 as i128) + Wrapping(i128_num2)).0)

1,000✔

739

);

1,000✔

740

        assert_eq!(

1,000✔

741

            // Int - I128 = I128

1,000✔

742

            evaluate_sub(&Schema::default(), &int1, &i128_2, &row)

1,000✔

743

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

744

            Field::I128((Wrapping(i_num1 as i128) - Wrapping(i128_num2)).0)

1,000✔

745

);

1,000✔

746

        assert_eq!(

1,000✔

747

            // Int * I128 = I128

1,000✔

748

            evaluate_mul(&Schema::default(), &int2, &i128_1, &row)

1,000✔

749

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

750

            Field::I128((Wrapping(i_num2 as i128) * Wrapping(i128_num1)).0)

1,000✔

751

);

1,000✔

752

        let res = evaluate_div(&Schema::default(), &int2, &i128_1, &row);

1,000✔

753

        if res.is_ok() {

1,000✔

754

            assert_eq!(

1,000✔

760

1,000✔

761

        assert_eq!(

1,000✔

762

            // Int % I128 = I128

1,000✔

763

            evaluate_mod(&Schema::default(), &int1, &i128_2, &row)

1,000✔

764

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

765

            Field::I128((Wrapping(i_num1 as i128) % Wrapping(i128_num2)).0)

1,000✔

766

);

1,000✔

767

1,000✔

768

        //// left: Int, right: Float

1,000✔

769

        assert_eq!(

1,000✔

770

            // Int + Float = Float

1,000✔

771

            evaluate_add(&Schema::default(), &int1, &float2, &row)

1,000✔

772

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

773

            Field::Float(OrderedFloat(f64::from_i64(i_num1).unwrap() + f_num2))

1,000✔

774

);

1,000✔

775

        assert_eq!(

1,000✔

776

            // Int - Float = Float

1,000✔

777

            evaluate_sub(&Schema::default(), &int1, &float2, &row)

1,000✔

778

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

779

            Field::Float(OrderedFloat(f64::from_i64(i_num1).unwrap() - f_num2))

1,000✔

780

);

1,000✔

781

        assert_eq!(

1,000✔

782

            // Int * Float = Float

1,000✔

783

            evaluate_mul(&Schema::default(), &int2, &float1, &row)

1,000✔

784

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

785

            Field::Float(OrderedFloat(f64::from_i64(i_num2).unwrap() * f_num1))

1,000✔

786

);

1,000✔

787

        if *float1 != Literal(Field::Float(OrderedFloat(0_f64))) {

1,000✔

788

            assert_eq!(

1,000✔

789

                // Int / Float = Float

835✔

790

                evaluate_div(&Schema::default(), &int2, &float1, &row)

835✔

791

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

835✔

792

                Field::Float(OrderedFloat(f64::from_i64(i_num2).unwrap() / f_num1))

835✔

793

);

835✔

794

1,000✔

795

        if *float2 != Literal(Field::Float(OrderedFloat(0_f64))) {

1,000✔

796

            assert_eq!(

1,000✔

797

                // Int % Float = Float

873✔

798

                evaluate_mod(&Schema::default(), &int1, &float2, &row)

873✔

799

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

873✔

800

                Field::Float(OrderedFloat(f64::from_i64(i_num1).unwrap() % f_num2))

873✔

801

);

873✔

802

1,000✔

803

1,000✔

804

        //// left: Int, right: Decimal

1,000✔

805

        assert_eq!(

1,000✔

806

            // Int + Decimal = Decimal

1,000✔

807

            evaluate_add(&Schema::default(), &int1, &dec2, &row)

1,000✔

808

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

809

            Field::Decimal(Decimal::from_i64(i_num1).unwrap() + d_num2.0)

1,000✔

810

);

1,000✔

811

        assert_eq!(

1,000✔

812

            // Int - Decimal = Decimal

1,000✔

813

            evaluate_sub(&Schema::default(), &int1, &dec2, &row)

1,000✔

814

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

815

            Field::Decimal(Decimal::from_i64(i_num1).unwrap() - d_num2.0)

1,000✔

816

);

1,000✔

817

        // Int * Decimal = Decimal

1,000✔

818

        let res = evaluate_mul(&Schema::default(), &int2, &dec1, &row);

1,000✔

819

        if res.is_ok() {

1,000✔

820

             assert_eq!(

1,000✔

821

                res.unwrap(), Field::Decimal(Decimal::from_i64(i_num2).unwrap().checked_mul(d_num1.0).unwrap())

719✔

822

);

719✔

823

        } else {

1,000✔

824

            assert!(res.is_err());

1,000✔

825

            assert!(matches!(

1,000✔

826

                res,

1,000✔

827

                Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

828

));

1,000✔

829

1,000✔

830

        // Int / Decimal = Decimal

1,000✔

831

        let res = evaluate_div(&Schema::default(), &int2, &dec1, &row);

1,000✔

832

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

833

            assert!(res.is_err());

1,000✔

834

            assert!(matches!(

1,000✔

835

                res,

1,000✔

836

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

837

));

1,000✔

838

1,000✔

839

        else if res.is_ok() {

1,000✔

840

             assert_eq!(

1,000✔

841

                res.unwrap(), Field::Decimal(Decimal::from_i64(i_num2).unwrap() / d_num1.0)

998✔

842

);

998✔

843

        } else {

1,000✔

844

            assert!(res.is_err());

1,000✔

845

            assert!(matches!(

1,000✔

846

                res,

1,000✔

847

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

848

));

1,000✔

849

1,000✔

850

        // Int % Decimal = Decimal

1,000✔

851

        let res = evaluate_mod(&Schema::default(), &int1, &dec2, &row);

1,000✔

852

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

853

            assert!(res.is_err());

1,000✔

854

            assert!(matches!(

1,000✔

855

                res,

1,000✔

856

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

857

));

1,000✔

858

1,000✔

859

        else if res.is_ok() {

1,000✔

860

             assert_eq!(

1,000✔

861

                res.unwrap(), Field::Decimal(Decimal::from_i64(i_num1).unwrap() % d_num2.0)

1,000✔

862

);

1,000✔

863

        } else {

1,000✔

864

            assert!(res.is_err());

1,000✔

865

            assert!(matches!(

1,000✔

866

                res,

1,000✔

867

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

868

));

1,000✔

869

1,000✔

870

1,000✔

871

        //// left: Int, right: Null

1,000✔

872

        assert_eq!(

1,000✔

873

            // Int + Null = Null

1,000✔

874

            evaluate_add(&Schema::default(), &int1, &null, &row)

1,000✔

875

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

876

            Field::Null

1,000✔

877

);

1,000✔

878

        assert_eq!(

1,000✔

879

            // Int - Null = Null

1,000✔

880

            evaluate_sub(&Schema::default(), &int1, &null, &row)

1,000✔

881

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

882

            Field::Null

1,000✔

883

);

1,000✔

884

        assert_eq!(

1,000✔

885

            // Int * Null = Null

1,000✔

886

            evaluate_mul(&Schema::default(), &int2, &null, &row)

1,000✔

887

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

888

            Field::Null

1,000✔

889

);

1,000✔

890

        assert_eq!(

1,000✔

891

            // Int / Null = Null

1,000✔

892

            evaluate_div(&Schema::default(), &int2, &null, &row)

1,000✔

893

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

894

            Field::Null

1,000✔

895

);

1,000✔

896

        assert_eq!(

1,000✔

897

            // Int % Null = Null

1,000✔

898

            evaluate_mod(&Schema::default(), &int1, &null, &row)

1,000✔

899

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

900

            Field::Null

1,000✔

901

);

1,000✔

902

});

1,000✔

903

1✔

905

#[test]

1✔

906

fn test_i128_math() {

1✔

907

    proptest!(ProptestConfig::with_cases(1000), move |(u_num1: u64, u_num2: u64, u128_num1: u128, u128_num2: u128, i_num1: i64, i_num2: i64, i128_num1: i128, i128_num2: i128, f_num1: f64, f_num2: f64, d_num1: ArbitraryDecimal, d_num2: ArbitraryDecimal)| {

1,000✔

908

        let row = Record::new(vec![]);

1,000✔

909

1,000✔

910

        let uint1 = Box::new(Literal(Field::UInt(u_num1)));

1,000✔

911

        let uint2 = Box::new(Literal(Field::UInt(u_num2)));

1,000✔

912

        let u128_1 = Box::new(Literal(Field::U128(u128_num1)));

1,000✔

913

        let u128_2 = Box::new(Literal(Field::U128(u128_num2)));

1,000✔

914

        let int1 = Box::new(Literal(Field::Int(i_num1)));

1,000✔

915

        let int2 = Box::new(Literal(Field::Int(i_num2)));

1,000✔

916

        let i128_1 = Box::new(Literal(Field::I128(i128_num1)));

1,000✔

917

        let i128_2 = Box::new(Literal(Field::I128(i128_num2)));

1,000✔

918

        let float1 = Box::new(Literal(Field::Float(OrderedFloat(f_num1))));

1,000✔

919

        let float2 = Box::new(Literal(Field::Float(OrderedFloat(f_num2))));

1,000✔

920

        let dec1 = Box::new(Literal(Field::Decimal(d_num1.0)));

1,000✔

921

        let dec2 = Box::new(Literal(Field::Decimal(d_num2.0)));

1,000✔

922

1,000✔

923

        let null = Box::new(Literal(Field::Null));

1,000✔

924

1,000✔

925

        //// left: I128, right: UInt

1,000✔

926

        assert_eq!(

1,000✔

927

            // I128 + UInt = I128

1,000✔

928

            evaluate_add(&Schema::default(), &i128_1, &uint2, &row)

1,000✔

929

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

930

            Field::I128((Wrapping(i128_num1) + Wrapping(u_num2 as i128)).0)

1,000✔

931

);

1,000✔

932

        assert_eq!(

1,000✔

933

            // I128 - UInt = I128

1,000✔

934

            evaluate_sub(&Schema::default(), &i128_1, &uint2, &row)

1,000✔

935

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

936

            Field::I128((Wrapping(i128_num1) - Wrapping(u_num2 as i128)).0)

1,000✔

937

);

1,000✔

938

        assert_eq!(

1,000✔

939

            // I128 * UInt = I128

1,000✔

940

            evaluate_mul(&Schema::default(), &i128_2, &uint1, &row)

1,000✔

941

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

942

            Field::I128((Wrapping(i128_num2) * Wrapping(u_num1 as i128)).0)

1,000✔

943

);

1,000✔

944

        let res = evaluate_div(&Schema::default(), &i128_2, &uint1, &row);

1,000✔

945

        if res.is_ok() {

1,000✔

946

            assert_eq!(

1,000✔

952

1,000✔

953

        assert_eq!(

1,000✔

954

            // I128 % UInt = I128

1,000✔

955

            evaluate_mod(&Schema::default(), &i128_1, &uint2, &row)

1,000✔

956

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

957

            Field::I128((Wrapping(i128_num1) % Wrapping(u_num2 as i128)).0)

1,000✔

958

);

1,000✔

959

1,000✔

960

        //// left: I128, right: U128

1,000✔

961

        assert_eq!(

1,000✔

962

            // I128 + U128 = I128

1,000✔

963

            evaluate_add(&Schema::default(), &i128_1, &u128_2, &row)

1,000✔

964

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

965

            Field::I128((Wrapping(i128_num1) + Wrapping(u128_num2 as i128)).0)

1,000✔

966

);

1,000✔

967

        assert_eq!(

1,000✔

968

            // I128 - U128 = I128

1,000✔

969

            evaluate_sub(&Schema::default(), &i128_1, &u128_2, &row)

1,000✔

970

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

971

            Field::I128((Wrapping(i128_num1) - Wrapping(u128_num2 as i128)).0)

1,000✔

972

);

1,000✔

973

        assert_eq!(

1,000✔

974

            // I128 * U128 = I128

1,000✔

975

            evaluate_mul(&Schema::default(), &i128_2, &u128_1, &row)

1,000✔

976

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

977

            Field::I128((Wrapping(i128_num2) * Wrapping(u128_num1 as i128)).0)

1,000✔

978

);

1,000✔

979

        let res = evaluate_div(&Schema::default(), &i128_2, &u128_1, &row);

1,000✔

980

        if res.is_ok() {

1,000✔

981

            assert_eq!(

1,000✔

986

1,000✔

987

        assert_eq!(

1,000✔

988

            // I128 % U128 = I128

1,000✔

989

            evaluate_mod(&Schema::default(), &i128_1, &u128_2, &row)

1,000✔

990

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

991

            Field::I128((Wrapping(i128_num1) % Wrapping(u128_num2 as i128)).0)

1,000✔

992

);

1,000✔

993

1,000✔

994

        //// left: I128, right: Int

1,000✔

995

        assert_eq!(

1,000✔

996

            // I128 + Int = I128

1,000✔

997

            evaluate_add(&Schema::default(), &i128_1, &int2, &row)

1,000✔

998

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

999

            Field::I128((Wrapping(i128_num1) + Wrapping(i_num2 as i128)).0)

1,000✔

1000

);

1,000✔

1001

        assert_eq!(

1,000✔

1002

            // I128 - Int = I128

1,000✔

1003

            evaluate_sub(&Schema::default(), &i128_1, &int2, &row)

1,000✔

1004

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1005

            Field::I128((Wrapping(i128_num1) - Wrapping(i_num2 as i128)).0)

1,000✔

1006

);

1,000✔

1007

        assert_eq!(

1,000✔

1008

            // I128 * Int = I128

1,000✔

1009

            evaluate_mul(&Schema::default(), &i128_2, &int1, &row)

1,000✔

1010

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1011

            Field::I128((Wrapping(i128_num2) * Wrapping(i_num1 as i128)).0)

1,000✔

1012

);

1,000✔

1013

        let res = evaluate_div(&Schema::default(), &i128_2, &int1, &row);

1,000✔

1014

        if res.is_ok() {

1,000✔

1015

            assert_eq!(

1,000✔

1021

1,000✔

1022

        assert_eq!(

1,000✔

1023

            // I128 % Int = I128

1,000✔

1024

            evaluate_mod(&Schema::default(), &i128_1, &int2, &row)

1,000✔

1025

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1026

            Field::I128((Wrapping(i128_num1) % Wrapping(i_num2 as i128)).0)

1,000✔

1027

);

1,000✔

1028

1,000✔

1029

        //// left: I128, right: I128

1,000✔

1030

        assert_eq!(

1,000✔

1031

            // I128 + I128 = I128

1,000✔

1032

            evaluate_add(&Schema::default(), &i128_1, &i128_2, &row)

1,000✔

1033

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1034

            Field::I128((Wrapping(i128_num1) + Wrapping(i128_num2)).0)

1,000✔

1035

);

1,000✔

1036

        assert_eq!(

1,000✔

1037

            // I128 - I128 = I128

1,000✔

1038

            evaluate_sub(&Schema::default(), &i128_1, &i128_2, &row)

1,000✔

1039

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1040

            Field::I128((Wrapping(i128_num1) - Wrapping(i128_num2)).0)

1,000✔

1041

);

1,000✔

1042

        assert_eq!(

1,000✔

1043

            // I128 * I128 = I128

1,000✔

1044

            evaluate_mul(&Schema::default(), &i128_2, &i128_1, &row)

1,000✔

1045

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1046

            Field::I128((Wrapping(i128_num2) * Wrapping(i128_num1)).0)

1,000✔

1047

);

1,000✔

1048

        let res = evaluate_div(&Schema::default(), &i128_2, &i128_1, &row);

1,000✔

1049

        if res.is_ok() {

1,000✔

1050

            assert_eq!(

1,000✔

1056

1,000✔

1057

        assert_eq!(

1,000✔

1058

            // I128 % I128 = I128

1,000✔

1059

            evaluate_mod(&Schema::default(), &i128_1, &i128_2, &row)

1,000✔

1060

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1061

            Field::I128((Wrapping(i128_num1) % Wrapping(i128_num2)).0)

1,000✔

1062

);

1,000✔

1063

1,000✔

1064

        //// left: I128, right: Float

1,000✔

1065

        let res = evaluate_add(&Schema::default(), &i128_1, &float2, &row);

1,000✔

1066

        if res.is_ok() {

1,000✔

1067

            assert_eq!(

1,000✔

1073

1,000✔

1074

        let res = evaluate_sub(&Schema::default(), &i128_1, &float2, &row);

1,000✔

1075

        if res.is_ok() {

1,000✔

1076

            assert_eq!(

1,000✔

1082

1,000✔

1083

        let res = evaluate_mul(&Schema::default(), &i128_2, &float1, &row);

1,000✔

1084

        if res.is_ok() {

1,000✔

1085

            assert_eq!(

1,000✔

1091

1,000✔

1092

        let res = evaluate_div(&Schema::default(), &i128_2, &float1, &row);

1,000✔

1093

        if res.is_ok() {

1,000✔

1094

            assert_eq!(

1,000✔

1100

1,000✔

1101

        let res = evaluate_mod(&Schema::default(), &i128_1, &float2, &row);

1,000✔

1102

        if res.is_ok() {

1,000✔

1103

            assert_eq!(

1,000✔

1109

1,000✔

1110

1,000✔

1111

        //// left: I128, right: Decimal

1,000✔

1112

        let res = evaluate_add(&Schema::default(), &i128_1, &dec2, &row);

1,000✔

1113

        if res.is_ok() {

1,000✔

1114

            assert_eq!(

1,000✔

1120

1,000✔

1121

        let res = evaluate_sub(&Schema::default(), &i128_1, &dec2, &row);

1,000✔

1122

        if res.is_ok() {

1,000✔

1123

            assert_eq!(

1,000✔

1129

1,000✔

1130

        // I128 * Decimal = Decimal

1,000✔

1131

        let res = evaluate_mul(&Schema::default(), &i128_2, &dec1, &row);

1,000✔

1132

        if res.is_ok() {

1,000✔

1133

             assert_eq!(

1,000✔

1136

        } else {

1,000✔

1137

            assert!(res.is_err());

1,000✔

1138

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1139

                assert!(matches!(

1,000✔

1140

                    res,

1,000✔

1141

                    Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

1142

));

1,000✔

1143

1,000✔

1144

1,000✔

1145

        // I128 / Decimal = Decimal

1,000✔

1146

        let res = evaluate_div(&Schema::default(), &i128_2, &dec1, &row);

1,000✔

1147

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1148

            assert!(res.is_err());

1,000✔

1149

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1150

                assert!(matches!(

1,000✔

1151

                    res,

1,000✔

1152

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1153

));

1,000✔

1154

1,000✔

1155

1,000✔

1156

        else if res.is_ok() {

1,000✔

1157

             assert_eq!(

1,000✔

1160

        } else {

1,000✔

1161

            assert!(res.is_err());

1,000✔

1162

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1163

                assert!(matches!(

1,000✔

1164

                    res,

1,000✔

1165

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1166

));

1,000✔

1167

1,000✔

1168

1,000✔

1169

        // I128 % Decimal = Decimal

1,000✔

1170

        let res = evaluate_mod(&Schema::default(), &i128_1, &dec2, &row);

1,000✔

1171

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1172

            assert!(res.is_err());

1,000✔

1173

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1174

                assert!(matches!(

1,000✔

1175

                    res,

1,000✔

1176

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1177

));

1,000✔

1178

1,000✔

1179

1,000✔

1180

        else if res.is_ok() {

1,000✔

1181

             assert_eq!(

1,000✔

1184

        } else {

1,000✔

1185

            assert!(res.is_err());

1,000✔

1186

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1187

                assert!(matches!(

1,000✔

1188

                    res,

1,000✔

1189

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1190

));

1,000✔

1191

1,000✔

1192

1,000✔

1193

1,000✔

1194

        //// left: I128, right: Null

1,000✔

1195

        assert_eq!(

1,000✔

1196

            // I128 + Null = Null

1,000✔

1197

            evaluate_add(&Schema::default(), &i128_1, &null, &row)

1,000✔

1198

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1199

            Field::Null

1,000✔

1200

);

1,000✔

1201

        assert_eq!(

1,000✔

1202

            // I128 - Null = Null

1,000✔

1203

            evaluate_sub(&Schema::default(), &i128_1, &null, &row)

1,000✔

1204

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1205

            Field::Null

1,000✔

1206

);

1,000✔

1207

        assert_eq!(

1,000✔

1208

            // I128 * Null = Null

1,000✔

1209

            evaluate_mul(&Schema::default(), &i128_2, &null, &row)

1,000✔

1210

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1211

            Field::Null

1,000✔

1212

);

1,000✔

1213

        assert_eq!(

1,000✔

1214

            // I128 / Null = Null

1,000✔

1215

            evaluate_div(&Schema::default(), &i128_2, &null, &row)

1,000✔

1216

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1217

            Field::Null

1,000✔

1218

);

1,000✔

1219

        assert_eq!(

1,000✔

1220

            // I128 % Null = Null

1,000✔

1221

            evaluate_mod(&Schema::default(), &i128_1, &null, &row)

1,000✔

1222

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1223

            Field::Null

1,000✔

1224

);

1,000✔

1225

});

1,000✔

1226

1✔

1228

#[test]

1✔

1229

fn test_float_math() {

1✔

1230

    proptest!(ProptestConfig::with_cases(1000), move |(u_num1: u64, u_num2: u64, u128_num1: u128, u128_num2: u128, i_num1: i64, i_num2: i64, i128_num1: i128, i128_num2: i128, f_num1: f64, f_num2: f64, d_num1: ArbitraryDecimal, d_num2: ArbitraryDecimal)| {

1,000✔

1231

        let row = Record::new(vec![]);

1,000✔

1232

1,000✔

1233

        let uint1 = Box::new(Literal(Field::UInt(u_num1)));

1,000✔

1234

        let uint2 = Box::new(Literal(Field::UInt(u_num2)));

1,000✔

1235

        let u128_1 = Box::new(Literal(Field::U128(u128_num1)));

1,000✔

1236

        let u128_2 = Box::new(Literal(Field::U128(u128_num2)));

1,000✔

1237

        let int1 = Box::new(Literal(Field::Int(i_num1)));

1,000✔

1238

        let int2 = Box::new(Literal(Field::Int(i_num2)));

1,000✔

1239

        let i128_1 = Box::new(Literal(Field::I128(i128_num1)));

1,000✔

1240

        let i128_2 = Box::new(Literal(Field::I128(i128_num2)));

1,000✔

1241

        let float1 = Box::new(Literal(Field::Float(OrderedFloat(f_num1))));

1,000✔

1242

        let float2 = Box::new(Literal(Field::Float(OrderedFloat(f_num2))));

1,000✔

1243

        let dec1 = Box::new(Literal(Field::Decimal(d_num1.0)));

1,000✔

1244

        let dec2 = Box::new(Literal(Field::Decimal(d_num2.0)));

1,000✔

1245

1,000✔

1246

        let null = Box::new(Literal(Field::Null));

1,000✔

1247

1,000✔

1248

        //// left: Float, right: UInt

1,000✔

1249

        assert_eq!(

1,000✔

1250

            // Float + UInt = Float

1,000✔

1251

            evaluate_add(&Schema::default(), &float1, &uint2, &row)

1,000✔

1252

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1253

            Field::Float(OrderedFloat(f_num1) + OrderedFloat(f64::from_u64(u_num2).unwrap()))

1,000✔

1254

);

1,000✔

1255

        assert_eq!(

1,000✔

1256

            // Float - UInt = Float

1,000✔

1257

            evaluate_sub(&Schema::default(), &float1, &uint2, &row)

1,000✔

1258

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1259

            Field::Float(OrderedFloat(f_num1) - OrderedFloat(f64::from_u64(u_num2).unwrap()))

1,000✔

1260

);

1,000✔

1261

        assert_eq!(

1,000✔

1262

            // Float * UInt = Float

1,000✔

1263

            evaluate_mul(&Schema::default(), &float2, &uint1, &row)

1,000✔

1264

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1265

            Field::Float(OrderedFloat(f_num2) * OrderedFloat(f64::from_u64(u_num1).unwrap()))

1,000✔

1266

);

1,000✔

1267

        assert_eq!(

1,000✔

1268

            // Float / UInt = Float

1,000✔

1269

            evaluate_div(&Schema::default(), &float2, &uint1, &row)

1,000✔

1270

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1271

            Field::Float(OrderedFloat(f_num2) / OrderedFloat(f64::from_u64(u_num1).unwrap()))

1,000✔

1272

);

1,000✔

1273

        assert_eq!(

1,000✔

1274

            // Float % UInt = Float

1,000✔

1275

            evaluate_mod(&Schema::default(), &float1, &uint2, &row)

1,000✔

1276

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1277

            Field::Float(OrderedFloat(f_num1) % OrderedFloat(f64::from_u64(u_num2).unwrap()))

1,000✔

1278

);

1,000✔

1279

1,000✔

1280

        //// left: Float, right: U128

1,000✔

1281

        let res = evaluate_add(&Schema::default(), &float1, &u128_2, &row);

1,000✔

1282

        if res.is_ok() {

1,000✔

1283

           assert_eq!(

1,000✔

1289

1,000✔

1290

        let res = evaluate_sub(&Schema::default(), &float1, &u128_2, &row);

1,000✔

1291

        if res.is_ok() {

1,000✔

1292

            assert_eq!(

1,000✔

1298

1,000✔

1299

        let res = evaluate_mul(&Schema::default(), &float2, &u128_1, &row);

1,000✔

1300

        if res.is_ok() {

1,000✔

1301

            assert_eq!(

1,000✔

1307

1,000✔

1308

        let res = evaluate_div(&Schema::default(), &float2, &u128_1, &row);

1,000✔

1309

        if res.is_ok() {

1,000✔

1310

            assert_eq!(

1,000✔

1316

1,000✔

1317

        let res = evaluate_mod(&Schema::default(), &float1, &u128_2, &row);

1,000✔

1318

        if res.is_ok() {

1,000✔

1319

            assert_eq!(

1,000✔

1325

1,000✔

1326

1,000✔

1327

        //// left: Float, right: Int

1,000✔

1328

        assert_eq!(

1,000✔

1329

            // Float + Int = Float

1,000✔

1330

            evaluate_add(&Schema::default(), &float1, &int2, &row)

1,000✔

1331

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1332

            Field::Float(OrderedFloat(f_num1) + OrderedFloat(f64::from_i64(i_num2).unwrap()))

1,000✔

1333

);

1,000✔

1334

        assert_eq!(

1,000✔

1335

            // Float - Int = Float

1,000✔

1336

            evaluate_sub(&Schema::default(), &float1, &int2, &row)

1,000✔

1337

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1338

            Field::Float(OrderedFloat(f_num1) - OrderedFloat(f64::from_i64(i_num2).unwrap()))

1,000✔

1339

);

1,000✔

1340

        assert_eq!(

1,000✔

1341

            // Float * Int = Float

1,000✔

1342

            evaluate_mul(&Schema::default(), &float2, &int1, &row)

1,000✔

1343

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1344

            Field::Float(OrderedFloat(f_num2) * OrderedFloat(f64::from_i64(i_num1).unwrap()))

1,000✔

1345

);

1,000✔

1346

        assert_eq!(

1,000✔

1347

            // Float / Int = Float

1,000✔

1348

            evaluate_div(&Schema::default(), &float2, &int1, &row)

1,000✔

1349

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1350

            Field::Float(OrderedFloat(f_num2) / OrderedFloat(f64::from_i64(i_num1).unwrap()))

1,000✔

1351

);

1,000✔

1352

        assert_eq!(

1,000✔

1353

            // Float % Int = Float

1,000✔

1354

            evaluate_mod(&Schema::default(), &float1, &int2, &row)

1,000✔

1355

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1356

            Field::Float(OrderedFloat(f_num1) % OrderedFloat(f64::from_i64(i_num2).unwrap()))

1,000✔

1357

);

1,000✔

1358

1,000✔

1359

        //// left: Float, right: I128

1,000✔

1360

        let res = evaluate_add(&Schema::default(), &float1, &i128_2, &row);

1,000✔

1361

        if res.is_ok() {

1,000✔

1362

            assert_eq!(

1,000✔

1368

1,000✔

1369

        let res = evaluate_sub(&Schema::default(), &float1, &i128_2, &row);

1,000✔

1370

        if res.is_ok() {

1,000✔

1371

            assert_eq!(

1,000✔

1377

1,000✔

1378

        let res = evaluate_mul(&Schema::default(), &float2, &i128_1, &row);

1,000✔

1379

        if res.is_ok() {

1,000✔

1380

            assert_eq!(

1,000✔

1386

1,000✔

1387

        let res = evaluate_div(&Schema::default(), &float2, &i128_1, &row);

1,000✔

1388

        if res.is_ok() {

1,000✔

1389

            assert_eq!(

1,000✔

1395

1,000✔

1396

        let res = evaluate_mod(&Schema::default(), &float1, &i128_2, &row);

1,000✔

1397

        if res.is_ok() {

1,000✔

1398

            assert_eq!(

1,000✔

1404

1,000✔

1405

1,000✔

1406

        //// left: Float, right: Float

1,000✔

1407

        assert_eq!(

1,000✔

1408

            // Float + Float = Float

1,000✔

1409

            evaluate_add(&Schema::default(), &float1, &float2, &row)

1,000✔

1410

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1411

            Field::Float(OrderedFloat(f_num1 + f_num2))

1,000✔

1412

);

1,000✔

1413

        assert_eq!(

1,000✔

1414

            // Float - Float = Float

1,000✔

1415

            evaluate_sub(&Schema::default(), &float1, &float2, &row)

1,000✔

1416

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1417

            Field::Float(OrderedFloat(f_num1 - f_num2))

1,000✔

1418

);

1,000✔

1419

        assert_eq!(

1,000✔

1420

            // Float * Float = Float

1,000✔

1421

            evaluate_mul(&Schema::default(), &float2, &float1, &row)

1,000✔

1422

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1423

            Field::Float(OrderedFloat(f_num2 * f_num1))

1,000✔

1424

);

1,000✔

1425

        if *float1 != Literal(Field::Float(OrderedFloat(0_f64))) {

1,000✔

1426

            assert_eq!(

1,000✔

1427

                // Float / Float = Float

864✔

1428

                evaluate_div(&Schema::default(), &float2, &float1, &row)

864✔

1429

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

864✔

1430

                Field::Float(OrderedFloat(f_num2 / f_num1))

864✔

1431

);

864✔

1432

1,000✔

1433

        if *float2 != Literal(Field::Float(OrderedFloat(0_f64))) {

1,000✔

1434

            assert_eq!(

1,000✔

1435

                // Float % Float = Float

854✔

1436

                evaluate_mod(&Schema::default(), &float1, &float2, &row)

854✔

1437

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

854✔

1438

                Field::Float(OrderedFloat(f_num1 % f_num2))

854✔

1439

);

854✔

1440

1,000✔

1441

1,000✔

1442

        //// left: Float, right: Decimal

1,000✔

1443

        let d_val1 = Decimal::from_f64(f_num1);

1,000✔

1444

        let d_val2 = Decimal::from_f64(f_num2);

1,000✔

1445

        if d_val1.is_some() && d_val2.is_some() {

1,000✔

1446

            assert_eq!(

1,000✔

1447

                // Float + Decimal = Decimal

430✔

1448

                evaluate_add(&Schema::default(), &float1, &dec2, &row)

430✔

1449

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

430✔

1450

                Field::Decimal(d_val1.unwrap() + d_num2.0)

430✔

1451

);

430✔

1452

            assert_eq!(

1,000✔

1453

                // Float - Decimal = Decimal

430✔

1454

                evaluate_sub(&Schema::default(), &float1, &dec2, &row)

430✔

1455

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

430✔

1456

                Field::Decimal(d_val1.unwrap() - d_num2.0)

430✔

1457

);

430✔

1458

            // Float * Decimal = Decimal

1,000✔

1459

            let res = evaluate_mul(&Schema::default(), &float2, &dec1, &row);

1,000✔

1460

            if res.is_ok() {

430✔

1461

                 assert_eq!(

1,000✔

1462

                    res.unwrap(), Field::Decimal(d_val2.unwrap().checked_mul(d_num1.0).unwrap())

426✔

1463

);

426✔

1464

            } else {

1,000✔

1465

                assert!(res.is_err());

1,000✔

1466

                assert!(matches!(

1,000✔

1467

                    res,

1,000✔

1468

                    Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

1469

));

1,000✔

1470

1,000✔

1471

            // Float / Decimal = Decimal

1,000✔

1472

            let res = evaluate_div(&Schema::default(), &float2, &dec1, &row);

1,000✔

1473

            if d_num1.0 == Decimal::new(0, 0) {

430✔

1474

                assert!(res.is_err());

1,000✔

1475

                assert!(matches!(

1,000✔

1476

                    res,

1,000✔

1477

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1478

));

1,000✔

1479

1,000✔

1480

            else if res.is_ok() {

1,000✔

1481

                 assert_eq!(

1,000✔

1482

                    res.unwrap(), Field::Decimal(d_val2.unwrap().checked_div(d_num1.0).unwrap())

429✔

1483

);

429✔

1484

            } else {

1,000✔

1485

                assert!(res.is_err());

1,000✔

1486

                assert!(matches!(

1,000✔

1487

                    res,

1,000✔

1488

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1489

));

1,000✔

1490

1,000✔

1491

            // Float % Decimal = Decimal

1,000✔

1492

            let res = evaluate_mod(&Schema::default(), &float1, &dec2, &row);

1,000✔

1493

            if d_num1.0 == Decimal::new(0, 0) {

430✔

1494

                assert!(res.is_err());

1,000✔

1495

                assert!(matches!(

1,000✔

1496

                    res,

1,000✔

1497

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1498

));

1,000✔

1499

1,000✔

1500

            else if res.is_ok() {

1,000✔

1501

                 assert_eq!(

1,000✔

1502

                    res.unwrap(), Field::Decimal(d_val1.unwrap().checked_rem(d_num2.0).unwrap())

430✔

1503

);

430✔

1504

            } else {

1,000✔

1505

                assert!(res.is_err());

1,000✔

1506

                assert!(matches!(

1,000✔

1507

                    res,

1,000✔

1508

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1509

));

1,000✔

1510

1,000✔

1511

1,000✔

1512

1,000✔

1513

        //// left: Float, right: Null

1,000✔

1514

        assert_eq!(

1,000✔

1515

            // Float + Null = Null

1,000✔

1516

            evaluate_add(&Schema::default(), &float1, &null, &row)

1,000✔

1517

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1518

            Field::Null

1,000✔

1519

);

1,000✔

1520

        assert_eq!(

1,000✔

1521

            // Float - Null = Null

1,000✔

1522

            evaluate_sub(&Schema::default(), &float1, &null, &row)

1,000✔

1523

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1524

            Field::Null

1,000✔

1525

);

1,000✔

1526

        assert_eq!(

1,000✔

1527

            // Float * Null = Null

1,000✔

1528

            evaluate_mul(&Schema::default(), &float2, &null, &row)

1,000✔

1529

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1530

            Field::Null

1,000✔

1531

);

1,000✔

1532

        assert_eq!(

1,000✔

1533

            // Float / Null = Null

1,000✔

1534

            evaluate_div(&Schema::default(), &float2, &null, &row)

1,000✔

1535

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1536

            Field::Null

1,000✔

1537

);

1,000✔

1538

        assert_eq!(

1,000✔

1539

            // Float % Null = Null

1,000✔

1540

            evaluate_mod(&Schema::default(), &float1, &null, &row)

1,000✔

1541

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1542

            Field::Null

1,000✔

1543

);

1,000✔

1544

});

1,000✔

1545

1✔

1547

#[test]

1✔

1548

fn test_decimal_math() {

1✔

1549

    proptest!(ProptestConfig::with_cases(1000), move |(u_num1: u64, u_num2: u64, u128_num1: u128, u128_num2: u128, i_num1: i64, i_num2: i64, i128_num1: i128, i128_num2: i128, f_num1: f64, f_num2: f64, d_num1: ArbitraryDecimal, d_num2: ArbitraryDecimal)| {

1,000✔

1550

        let row = Record::new(vec![]);

1,000✔

1551

1,000✔

1552

        let uint1 = Box::new(Literal(Field::UInt(u_num1)));

1,000✔

1553

        let uint2 = Box::new(Literal(Field::UInt(u_num2)));

1,000✔

1554

        let u128_1 = Box::new(Literal(Field::U128(u128_num1)));

1,000✔

1555

        let u128_2 = Box::new(Literal(Field::U128(u128_num2)));

1,000✔

1556

        let int1 = Box::new(Literal(Field::Int(i_num1)));

1,000✔

1557

        let int2 = Box::new(Literal(Field::Int(i_num2)));

1,000✔

1558

        let i128_1 = Box::new(Literal(Field::I128(i128_num1)));

1,000✔

1559

        let i128_2 = Box::new(Literal(Field::I128(i128_num2)));

1,000✔

1560

        let float1 = Box::new(Literal(Field::Float(OrderedFloat(f_num1))));

1,000✔

1561

        let float2 = Box::new(Literal(Field::Float(OrderedFloat(f_num2))));

1,000✔

1562

        let dec1 = Box::new(Literal(Field::Decimal(d_num1.0)));

1,000✔

1563

        let dec2 = Box::new(Literal(Field::Decimal(d_num2.0)));

1,000✔

1564

1,000✔

1565

        let null = Box::new(Literal(Field::Null));

1,000✔

1566

1,000✔

1567

        //// left: Decimal, right: UInt

1,000✔

1568

        assert_eq!(

1,000✔

1569

            // Decimal + UInt = Decimal

1,000✔

1570

            evaluate_add(&Schema::default(), &dec1, &uint2, &row)

1,000✔

1571

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1572

            Field::Decimal(d_num1.0 + Decimal::from(u_num2))

1,000✔

1573

);

1,000✔

1574

        assert_eq!(

1,000✔

1575

            // Decimal - UInt = Decimal

1,000✔

1576

            evaluate_sub(&Schema::default(), &dec1, &uint2, &row)

1,000✔

1577

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1578

            Field::Decimal(d_num1.0 - Decimal::from(u_num2))

1,000✔

1579

);

1,000✔

1580

        // Decimal * UInt = Decimal

1,000✔

1581

        let res = evaluate_mul(&Schema::default(), &dec2, &uint1, &row);

1,000✔

1582

        if res.is_ok() {

1,000✔

1583

             assert_eq!(

1,000✔

1584

                res.unwrap(), Field::Decimal(d_num2.0 * Decimal::from(u_num1))

678✔

1585

);

678✔

1586

        } else {

1,000✔

1587

            assert!(res.is_err());

1,000✔

1588

            assert!(matches!(

1,000✔

1589

                res,

1,000✔

1590

                Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

1591

));

1,000✔

1592

1,000✔

1593

        // Decimal / UInt = Decimal

1,000✔

1594

        let res = evaluate_div(&Schema::default(), &dec2, &uint1, &row);

1,000✔

1595

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1596

            assert!(res.is_err());

1,000✔

1597

            assert!(matches!(

1,000✔

1598

                res,

1,000✔

1599

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1600

));

1,000✔

1601

1,000✔

1602

        else if res.is_ok() {

1,000✔

1603

             assert_eq!(

1,000✔

1604

                res.unwrap(), Field::Decimal(d_num2.0 / Decimal::from(u_num1))

1,000✔

1605

);

1,000✔

1606

        } else {

1,000✔

1607

            assert!(res.is_err());

1,000✔

1608

            assert!(matches!(

1,000✔

1609

                res,

1,000✔

1610

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1611

));

1,000✔

1612

1,000✔

1613

        // Decimal % UInt = Decimal

1,000✔

1614

        let res = evaluate_mod(&Schema::default(), &dec1, &uint2, &row);

1,000✔

1615

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1616

            assert!(res.is_err());

1,000✔

1617

            assert!(matches!(

1,000✔

1618

                res,

1,000✔

1619

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1620

));

1,000✔

1621

1,000✔

1622

        else if res.is_ok() {

1,000✔

1623

             assert_eq!(

1,000✔

1624

                res.unwrap(), Field::Decimal(d_num1.0 % Decimal::from(u_num2))

1,000✔

1625

);

1,000✔

1626

        } else {

1,000✔

1627

            assert!(res.is_err());

1,000✔

1628

            assert!(matches!(

1,000✔

1629

                res,

1,000✔

1630

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1631

));

1,000✔

1632

1,000✔

1633

1,000✔

1634

        //// left: Decimal, right: U128

1,000✔

1635

        let res = evaluate_add(&Schema::default(), &dec1, &u128_2, &row);

1,000✔

1636

        if res.is_ok() {

1,000✔

1637

            assert_eq!(

1,000✔

1643

1,000✔

1644

        let res = evaluate_sub(&Schema::default(), &dec1, &u128_2, &row);

1,000✔

1645

        if res.is_ok() {

1,000✔

1646

            assert_eq!(

1,000✔

1652

1,000✔

1653

        // Decimal * U128 = Decimal

1,000✔

1654

        let res = evaluate_mul(&Schema::default(), &dec2, &u128_1, &row);

1,000✔

1655

        if res.is_ok() {

1,000✔

1656

             assert_eq!(

1,000✔

1659

        } else {

1,000✔

1660

            assert!(res.is_err());

1,000✔

1661

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1662

                assert!(matches!(

1,000✔

1663

                    res,

1,000✔

1664

                    Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

1665

));

1,000✔

1666

1,000✔

1667

1,000✔

1668

        // Decimal / U128 = Decimal

1,000✔

1669

        let res = evaluate_div(&Schema::default(), &dec2, &u128_1, &row);

1,000✔

1670

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1671

            assert!(res.is_err());

1,000✔

1672

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1673

                assert!(matches!(

1,000✔

1674

                    res,

1,000✔

1675

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1676

));

1,000✔

1677

1,000✔

1678

1,000✔

1679

        else if res.is_ok() {

1,000✔

1680

             assert_eq!(

1,000✔

1683

        } else {

1,000✔

1684

            assert!(res.is_err());

1,000✔

1685

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1686

                assert!(matches!(

1,000✔

1687

                    res,

1,000✔

1688

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1689

));

1,000✔

1690

1,000✔

1691

1,000✔

1692

        // Decimal % U128 = Decimal

1,000✔

1693

        let res = evaluate_mod(&Schema::default(), &dec1, &u128_2, &row);

1,000✔

1694

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1695

            assert!(res.is_err());

1,000✔

1696

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1697

                assert!(matches!(

1,000✔

1698

                    res,

1,000✔

1699

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1700

));

1,000✔

1701

1,000✔

1702

1,000✔

1703

        else if res.is_ok() {

1,000✔

1704

             assert_eq!(

1,000✔

1707

        } else {

1,000✔

1708

            assert!(res.is_err());

1,000✔

1709

            if !matches!(res, Err(PipelineError::UnableToCast(_, _))) {

1,000✔

1710

                assert!(matches!(

1,000✔

1711

                    res,

1,000✔

1712

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1713

));

1,000✔

1714

1,000✔

1715

1,000✔

1716

1,000✔

1717

        //// left: Decimal, right: Int

1,000✔

1718

        assert_eq!(

1,000✔

1719

            // Decimal + Int = Decimal

1,000✔

1720

            evaluate_add(&Schema::default(), &dec1, &int2, &row)

1,000✔

1721

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1722

            Field::Decimal(d_num1.0 + Decimal::from(i_num2))

1,000✔

1723

);

1,000✔

1724

        assert_eq!(

1,000✔

1725

            // Decimal - Int = Decimal

1,000✔

1726

            evaluate_sub(&Schema::default(), &dec1, &int2, &row)

1,000✔

1727

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1728

            Field::Decimal(d_num1.0 - Decimal::from(i_num2))

1,000✔

1729

);

1,000✔

1730

        let res = evaluate_mul(&Schema::default(), &dec2, &int1, &row);

1,000✔

1731

        if res.is_ok() {

1,000✔

1732

            assert_eq!(

1,000✔

1733

                // Decimal * Int = Decimal

685✔

1734

                evaluate_mul(&Schema::default(), &dec2, &int1, &row)

685✔

1735

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

685✔

1736

                Field::Decimal(d_num2.0 * Decimal::from(i_num1))

685✔

1737

);

685✔

1738

1,000✔

1739

        assert_eq!(

1,000✔

1740

            // Decimal / Int = Decimal

1,000✔

1741

            evaluate_div(&Schema::default(), &dec2, &int1, &row)

1,000✔

1742

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1743

            Field::Decimal(d_num2.0 / Decimal::from(i_num1))

1,000✔

1744

);

1,000✔

1745

        assert_eq!(

1,000✔

1746

            // Decimal % Int = Decimal

1,000✔

1747

            evaluate_mod(&Schema::default(), &dec1, &int2, &row)

1,000✔

1748

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1749

            Field::Decimal(d_num1.0 % Decimal::from(i_num2))

1,000✔

1750

);

1,000✔

1751

1,000✔

1752

        //// left: Decimal, right: I128

1,000✔

1753

        let res = evaluate_add(&Schema::default(), &dec1, &i128_2, &row);

1,000✔

1754

        if res.is_ok() {

1,000✔

1755

            assert_eq!(

1,000✔

1761

1,000✔

1762

        let res = evaluate_sub(&Schema::default(), &dec1, &i128_2, &row);

1,000✔

1763

        if res.is_ok() {

1,000✔

1764

            assert_eq!(

1,000✔

1770

1,000✔

1771

        let res = evaluate_mul(&Schema::default(), &dec2, &i128_1, &row);

1,000✔

1772

        if res.is_ok() {

1,000✔

1773

            assert_eq!(

1,000✔

1779

1,000✔

1780

        let res = evaluate_div(&Schema::default(), &dec2, &i128_1, &row);

1,000✔

1781

        if res.is_ok() {

1,000✔

1782

            assert_eq!(

1,000✔

1788

1,000✔

1789

        let res = evaluate_mod(&Schema::default(), &dec1, &i128_2, &row);

1,000✔

1790

        if res.is_ok() {

1,000✔

1791

            assert_eq!(

1,000✔

1797

1,000✔

1798

1,000✔

1799

        // left: Decimal, right: Float

1,000✔

1800

        let d_val1 = Decimal::from_f64(f_num1);

1,000✔

1801

        let d_val2 = Decimal::from_f64(f_num2);

1,000✔

1802

        if d_val1.is_some() && d_val2.is_some() && d_val1.unwrap() != Decimal::new(0, 0) && d_val2.unwrap() != Decimal::new(0, 0) {

1,000✔

1803

            assert_eq!(

1,000✔

1804

                // Decimal + Float = Decimal

3✔

1805

                evaluate_add(&Schema::default(), &dec1, &float2, &row)

3✔

1806

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

3✔

1807

                Field::Decimal(d_num1.0 + d_val2.unwrap())

3✔

1808

);

3✔

1809

            assert_eq!(

1,000✔

1810

                // Decimal - Float = Decimal

3✔

1811

                evaluate_sub(&Schema::default(), &dec1, &float2, &row)

3✔

1812

                    .unwrap_or_else(|e| panic!("{}", e.to_string())),

3✔

1813

                Field::Decimal(d_num1.0 - d_val2.unwrap())

3✔

1814

);

3✔

1815

            // Decimal * Float = Decimal

1,000✔

1816

            let res = evaluate_mul(&Schema::default(), &dec2, &float1, &row);

1,000✔

1817

            if res.is_ok() {

3✔

1818

                 assert_eq!(

1,000✔

1819

                    res.unwrap(), Field::Decimal(d_num2.0 * d_val1.unwrap())

3✔

1820

);

3✔

1821

            } else {

1,000✔

1822

                assert!(res.is_err());

1,000✔

1823

                assert!(matches!(

1,000✔

1824

                    res,

1,000✔

1825

                    Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

1826

));

1,000✔

1827

1,000✔

1828

            // Decimal / Float = Decimal

1,000✔

1829

            let res = evaluate_div(&Schema::default(), &dec2, &float1, &row);

1,000✔

1830

            if d_num1.0 == Decimal::new(0, 0) {

3✔

1831

                assert!(res.is_err());

1,000✔

1832

                assert!(matches!(

1,000✔

1833

                    res,

1,000✔

1834

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1835

));

1,000✔

1836

1,000✔

1837

            else if res.is_ok() {

1,000✔

1838

                 assert_eq!(

1,000✔

1839

                    res.unwrap(), Field::Decimal(d_num2.0 / d_val1.unwrap())

3✔

1840

);

3✔

1841

            } else {

1,000✔

1842

                assert!(res.is_err());

1,000✔

1843

                assert!(matches!(

1,000✔

1844

                    res,

1,000✔

1845

                    Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1846

));

1,000✔

1847

1,000✔

1848

            // Decimal % Float = Decimal

1,000✔

1849

            let res = evaluate_mod(&Schema::default(), &dec1, &float2, &row);

1,000✔

1850

            if d_num1.0 == Decimal::new(0, 0) {

3✔

1851

                assert!(res.is_err());

1,000✔

1852

                assert!(matches!(

1,000✔

1853

                    res,

1,000✔

1854

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1855

));

1,000✔

1856

1,000✔

1857

            else if res.is_ok() {

1,000✔

1858

                 assert_eq!(

1,000✔

1859

                    res.unwrap(),Field::Decimal(d_num1.0 % d_val2.unwrap())

3✔

1860

);

3✔

1861

            } else {

1,000✔

1862

                assert!(res.is_err());

1,000✔

1863

                assert!(matches!(

1,000✔

1864

                    res,

1,000✔

1865

                    Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1866

));

1,000✔

1867

1,000✔

1868

1,000✔

1869

1,000✔

1870

1,000✔

1871

        //// left: Decimal, right: Decimal

1,000✔

1872

        assert_eq!(

1,000✔

1873

            // Decimal + Decimal = Decimal

1,000✔

1874

            evaluate_add(&Schema::default(), &dec1, &dec2, &row)

1,000✔

1875

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1876

            Field::Decimal(d_num1.0 + d_num2.0)

1,000✔

1877

);

1,000✔

1878

        assert_eq!(

1,000✔

1879

            // Decimal - Decimal = Decimal

1,000✔

1880

            evaluate_sub(&Schema::default(), &dec1, &dec2, &row)

1,000✔

1881

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1882

            Field::Decimal(d_num1.0 - d_num2.0)

1,000✔

1883

);

1,000✔

1884

        // Decimal * Decimal = Decimal

1,000✔

1885

        let res = evaluate_mul(&Schema::default(), &dec2, &dec1, &row);

1,000✔

1886

        if res.is_ok() {

1,000✔

1887

             assert_eq!(

1,000✔

1888

                res.unwrap(), Field::Decimal(d_num2.0 * d_num1.0)

942✔

1889

);

942✔

1890

        } else {

1,000✔

1891

            assert!(res.is_err());

1,000✔

1892

            assert!(matches!(

1,000✔

1893

                res,

1,000✔

1894

                Err(PipelineError::SqlError(Operation(OperationError::MultiplicationOverflow)))

1,000✔

1895

));

1,000✔

1896

1,000✔

1897

        // Decimal / Decimal = Decimal

1,000✔

1898

        let res = evaluate_div(&Schema::default(), &dec2, &dec1, &row);

1,000✔

1899

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1900

            assert!(res.is_err());

1,000✔

1901

            assert!(matches!(

1,000✔

1902

                res,

1,000✔

1903

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1904

));

1,000✔

1905

1,000✔

1906

        else if res.is_ok() {

1,000✔

1907

             assert_eq!(

1,000✔

1908

                res.unwrap(), Field::Decimal(d_num2.0 / d_num1.0)

1,000✔

1909

);

1,000✔

1910

        } else {

1,000✔

1911

            assert!(res.is_err());

1,000✔

1912

            assert!(matches!(

1,000✔

1913

                res,

1,000✔

1914

                Err(PipelineError::SqlError(Operation(OperationError::DivisionByZeroOrOverflow)))

1,000✔

1915

));

1,000✔

1916

1,000✔

1917

        // Decimal % Decimal = Decimal

1,000✔

1918

        let res = evaluate_mod(&Schema::default(), &dec1, &dec2, &row);

1,000✔

1919

        if d_num1.0 == Decimal::new(0, 0) {

1,000✔

1920

            assert!(res.is_err());

1,000✔

1921

            assert!(matches!(

1,000✔

1922

                res,

1,000✔

1923

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1924

));

1,000✔

1925

1,000✔

1926

        else if res.is_ok() {

1,000✔

1927

             assert_eq!(

1,000✔

1928

                res.unwrap(), Field::Decimal(d_num1.0 % d_num2.0)

1,000✔

1929

);

1,000✔

1930

        } else {

1,000✔

1931

            assert!(res.is_err());

1,000✔

1932

            assert!(matches!(

1,000✔

1933

                res,

1,000✔

1934

                Err(PipelineError::SqlError(Operation(OperationError::ModuloByZeroOrOverflow)))

1,000✔

1935

));

1,000✔

1936

1,000✔

1937

1,000✔

1938

        //// left: Decimal, right: Null

1,000✔

1939

        assert_eq!(

1,000✔

1940

            // Decimal + Null = Null

1,000✔

1941

            evaluate_add(&Schema::default(), &dec1, &null, &row)

1,000✔

1942

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1943

            Field::Null

1,000✔

1944

);

1,000✔

1945

        assert_eq!(

1,000✔

1946

            // Decimal - Null = Null

1,000✔

1947

            evaluate_sub(&Schema::default(), &dec1, &null, &row)

1,000✔

1948

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1949

            Field::Null

1,000✔

1950

);

1,000✔

1951

        assert_eq!(

1,000✔

1952

            // Decimal * Null = Null

1,000✔

1953

            evaluate_mul(&Schema::default(), &dec2, &null, &row)

1,000✔

1954

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1955

            Field::Null

1,000✔

1956

);

1,000✔

1957

        assert_eq!(

1,000✔

1958

            // Decimal / Null = Null

1,000✔

1959

            evaluate_div(&Schema::default(), &dec2, &null, &row)

1,000✔

1960

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1961

            Field::Null

1,000✔

1962

);

1,000✔

1963

        assert_eq!(

1,000✔

1964

            // Decimal % Null = Null

1,000✔

1965

            evaluate_mod(&Schema::default(), &dec1, &null, &row)

1,000✔

1966

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1967

            Field::Null

1,000✔

1968

);

1,000✔

1969

})

1,000✔

1970

1✔

1972

#[test]

1✔

1973

fn test_null_math() {

1✔

1974

    proptest!(ProptestConfig::with_cases(1000), move |(u_num1: u64, u_num2: u64, u128_num1: u128, u128_num2: u128, i_num1: i64, i_num2: i64, i128_num1: i128, i128_num2: i128, f_num1: f64, f_num2: f64, d_num1: ArbitraryDecimal, d_num2: ArbitraryDecimal)| {

1,000✔

1975

        let row = Record::new(vec![]);

1,000✔

1976

1,000✔

1977

        let uint1 = Box::new(Literal(Field::UInt(u_num1)));

1,000✔

1978

        let uint2 = Box::new(Literal(Field::UInt(u_num2)));

1,000✔

1979

        let u128_1 = Box::new(Literal(Field::U128(u128_num1)));

1,000✔

1980

        let u128_2 = Box::new(Literal(Field::U128(u128_num2)));

1,000✔

1981

        let int1 = Box::new(Literal(Field::Int(i_num1)));

1,000✔

1982

        let int2 = Box::new(Literal(Field::Int(i_num2)));

1,000✔

1983

        let i128_1 = Box::new(Literal(Field::I128(i128_num1)));

1,000✔

1984

        let i128_2 = Box::new(Literal(Field::I128(i128_num2)));

1,000✔

1985

        let float1 = Box::new(Literal(Field::Float(OrderedFloat(f_num1))));

1,000✔

1986

        let float2 = Box::new(Literal(Field::Float(OrderedFloat(f_num2))));

1,000✔

1987

        let dec1 = Box::new(Literal(Field::Decimal(d_num1.0)));

1,000✔

1988

        let dec2 = Box::new(Literal(Field::Decimal(d_num2.0)));

1,000✔

1989

1,000✔

1990

        let null = Box::new(Literal(Field::Null));

1,000✔

1991

1,000✔

1992

        //// left: Null, right: UInt

1,000✔

1993

        assert_eq!(

1,000✔

1994

            // Null + UInt = Null

1,000✔

1995

            evaluate_add(&Schema::default(), &null, &uint2, &row)

1,000✔

1996

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

1997

            Field::Null

1,000✔

1998

);

1,000✔

1999

        assert_eq!(

1,000✔

2000

            // Null - UInt = Null

1,000✔

2001

            evaluate_sub(&Schema::default(), &null, &uint2, &row)

1,000✔

2002

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2003

            Field::Null

1,000✔

2004

);

1,000✔

2005

        assert_eq!(

1,000✔

2006

            // Null * UInt = Null

1,000✔

2007

            evaluate_mul(&Schema::default(), &null, &uint1, &row)

1,000✔

2008

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2009

            Field::Null

1,000✔

2010

);

1,000✔

2011

        assert_eq!(

1,000✔

2012

            // Decimal / UInt = Null

1,000✔

2013

            evaluate_div(&Schema::default(), &null, &uint1, &row)

1,000✔

2014

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2015

            Field::Null

1,000✔

2016

);

1,000✔

2017

        assert_eq!(

1,000✔

2018

            // Decimal % UInt = Null

1,000✔

2019

            evaluate_mod(&Schema::default(), &null, &uint2, &row)

1,000✔

2020

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2021

            Field::Null

1,000✔

2022

);

1,000✔

2023

1,000✔

2024

        //// left: Null, right: U128

1,000✔

2025

        assert_eq!(

1,000✔

2026

            // Null + U128 = Null

1,000✔

2027

            evaluate_add(&Schema::default(), &null, &u128_2, &row)

1,000✔

2028

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2029

            Field::Null

1,000✔

2030

);

1,000✔

2031

        assert_eq!(

1,000✔

2032

            // Null - U128 = Null

1,000✔

2033

            evaluate_sub(&Schema::default(), &null, &u128_2, &row)

1,000✔

2034

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2035

            Field::Null

1,000✔

2036

);

1,000✔

2037

        assert_eq!(

1,000✔

2038

            // Null * U128 = Null

1,000✔

2039

            evaluate_mul(&Schema::default(), &null, &u128_1, &row)

1,000✔

2040

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2041

            Field::Null

1,000✔

2042

);

1,000✔

2043

        assert_eq!(

1,000✔

2044

            // Decimal / U128 = Null

1,000✔

2045

            evaluate_div(&Schema::default(), &null, &u128_1, &row)

1,000✔

2046

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2047

            Field::Null

1,000✔

2048

);

1,000✔

2049

        assert_eq!(

1,000✔

2050

            // Decimal % U128 = Null

1,000✔

2051

            evaluate_mod(&Schema::default(), &null, &u128_2, &row)

1,000✔

2052

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2053

            Field::Null

1,000✔

2054

);

1,000✔

2055

1,000✔

2056

        //// left: Null, right: Int

1,000✔

2057

        assert_eq!(

1,000✔

2058

            // Null + Int = Null

1,000✔

2059

            evaluate_add(&Schema::default(), &null, &int2, &row)

1,000✔

2060

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2061

            Field::Null

1,000✔

2062

);

1,000✔

2063

        assert_eq!(

1,000✔

2064

            // Null - Int = Null

1,000✔

2065

            evaluate_sub(&Schema::default(), &null, &int2, &row)

1,000✔

2066

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2067

            Field::Null

1,000✔

2068

);

1,000✔

2069

        assert_eq!(

1,000✔

2070

            // Null * Int = Null

1,000✔

2071

            evaluate_mul(&Schema::default(), &null, &int1, &row)

1,000✔

2072

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2073

            Field::Null

1,000✔

2074

);

1,000✔

2075

        assert_eq!(

1,000✔

2076

            // Decimal / Int = Null

1,000✔

2077

            evaluate_div(&Schema::default(), &null, &int1, &row)

1,000✔

2078

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2079

            Field::Null

1,000✔

2080

);

1,000✔

2081

        assert_eq!(

1,000✔

2082

            // Decimal % Int = Null

1,000✔

2083

            evaluate_mod(&Schema::default(), &null, &int2, &row)

1,000✔

2084

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2085

            Field::Null

1,000✔

2086

);

1,000✔

2087

1,000✔

2088

        //// left: Null, right: I128

1,000✔

2089

        assert_eq!(

1,000✔

2090

            // Null + I128 = Null

1,000✔

2091

            evaluate_add(&Schema::default(), &null, &i128_2, &row)

1,000✔

2092

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2093

            Field::Null

1,000✔

2094

);

1,000✔

2095

        assert_eq!(

1,000✔

2096

            // Null - I128 = Null

1,000✔

2097

            evaluate_sub(&Schema::default(), &null, &i128_2, &row)

1,000✔

2098

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2099

            Field::Null

1,000✔

2100

);

1,000✔

2101

        assert_eq!(

1,000✔

2102

            // Null * I128 = Null

1,000✔

2103

            evaluate_mul(&Schema::default(), &null, &i128_1, &row)

1,000✔

2104

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2105

            Field::Null

1,000✔

2106

);

1,000✔

2107

        assert_eq!(

1,000✔

2108

            // Decimal / I128 = Null

1,000✔

2109

            evaluate_div(&Schema::default(), &null, &i128_1, &row)

1,000✔

2110

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2111

            Field::Null

1,000✔

2112

);

1,000✔

2113

        assert_eq!(

1,000✔

2114

            // Decimal % I128 = Null

1,000✔

2115

            evaluate_mod(&Schema::default(), &null, &i128_2, &row)

1,000✔

2116

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2117

            Field::Null

1,000✔

2118

);

1,000✔

2119

1,000✔

2120

        //// left: Null, right: Float

1,000✔

2121

        assert_eq!(

1,000✔

2122

            // Null + Float = Null

1,000✔

2123

            evaluate_add(&Schema::default(), &null, &float2, &row)

1,000✔

2124

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2125

            Field::Null

1,000✔

2126

);

1,000✔

2127

        assert_eq!(

1,000✔

2128

            // Null - Float = Null

1,000✔

2129

            evaluate_sub(&Schema::default(), &null, &float2, &row)

1,000✔

2130

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2131

            Field::Null

1,000✔

2132

);

1,000✔

2133

        assert_eq!(

1,000✔

2134

            // Null * Float = Null

1,000✔

2135

            evaluate_mul(&Schema::default(), &null, &float1, &row)

1,000✔

2136

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2137

            Field::Null

1,000✔

2138

);

1,000✔

2139

        assert_eq!(

1,000✔

2140

            // Decimal / Float = Null

1,000✔

2141

            evaluate_div(&Schema::default(), &null, &float1, &row)

1,000✔

2142

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2143

            Field::Null

1,000✔

2144

);

1,000✔

2145

        assert_eq!(

1,000✔

2146

            // Decimal % Float = Null

1,000✔

2147

            evaluate_mod(&Schema::default(), &null, &float2, &row)

1,000✔

2148

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2149

            Field::Null

1,000✔

2150

);

1,000✔

2151

1,000✔

2152

        //// left: Null, right: Decimal

1,000✔

2153

        assert_eq!(

1,000✔

2154

            // Null + Decimal = Null

1,000✔

2155

            evaluate_add(&Schema::default(), &null, &dec2, &row)

1,000✔

2156

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2157

            Field::Null

1,000✔

2158

);

1,000✔

2159

        assert_eq!(

1,000✔

2160

            // Null - Decimal = Null

1,000✔

2161

            evaluate_sub(&Schema::default(), &null, &dec2, &row)

1,000✔

2162

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2163

            Field::Null

1,000✔

2164

);

1,000✔

2165

        assert_eq!(

1,000✔

2166

            // Null * Decimal = Null

1,000✔

2167

            evaluate_mul(&Schema::default(), &null, &dec1, &row)

1,000✔

2168

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2169

            Field::Null

1,000✔

2170

);

1,000✔

2171

        assert_eq!(

1,000✔

2172

            // Decimal / Decimal = Null

1,000✔

2173

            evaluate_div(&Schema::default(), &null, &dec1, &row)

1,000✔

2174

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2175

            Field::Null

1,000✔

2176

);

1,000✔

2177

        assert_eq!(

1,000✔

2178

            // Decimal % Decimal = Null

1,000✔

2179

            evaluate_mod(&Schema::default(), &null, &dec2, &row)

1,000✔

2180

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2181

            Field::Null

1,000✔

2182

);

1,000✔

2183

1,000✔

2184

        //// left: Null, right: Null

1,000✔

2185

        assert_eq!(

1,000✔

2186

            // Null + Null = Null

1,000✔

2187

            evaluate_add(&Schema::default(), &null, &null, &row)

1,000✔

2188

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2189

            Field::Null

1,000✔

2190

);

1,000✔

2191

        assert_eq!(

1,000✔

2192

            // Null - Null = Null

1,000✔

2193

            evaluate_sub(&Schema::default(), &null, &null, &row)

1,000✔

2194

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2195

            Field::Null

1,000✔

2196

);

1,000✔

2197

        assert_eq!(

1,000✔

2198

            // Null * Null = Null

1,000✔

2199

            evaluate_mul(&Schema::default(), &null, &null, &row)

1,000✔

2200

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2201

            Field::Null

1,000✔

2202

);

1,000✔

2203

        assert_eq!(

1,000✔

2204

            // Decimal / Null = Null

1,000✔

2205

            evaluate_div(&Schema::default(), &null, &null, &row)

1,000✔

2206

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2207

            Field::Null

1,000✔

2208

);

1,000✔

2209

        assert_eq!(

1,000✔

2210

            // Decimal % Null = Null

1,000✔

2211

            evaluate_mod(&Schema::default(), &null, &null, &row)

1,000✔

2212

                .unwrap_or_else(|e| panic!("{}", e.to_string())),

1,000✔

2213

            Field::Null

1,000✔

2214

);

1,000✔

2215

})

1,000✔

2216

1✔

getdozer / dozer / 5640948961

Source File
Press 'n' to go to next uncovered line, 'b' for previous

getdozer / dozer / 5640948961

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous