From 4242894f711f127500736bbb497a5a7d46a108d7 Mon Sep 17 00:00:00 2001 From: jayzhan211 Date: Thu, 20 Jul 2023 14:25:52 +0800 Subject: [PATCH] remove proto files Signed-off-by: jayzhan211 --- datafusion/proto/proto/proto_descriptor.bin | Bin 88978 -> 0 bytes datafusion/proto/src/datafusion.rs | 2917 --- datafusion/proto/src/datafusion.serde.rs | 23148 ------------------ 3 files changed, 26065 deletions(-) delete mode 100644 datafusion/proto/proto/proto_descriptor.bin delete mode 100644 datafusion/proto/src/datafusion.rs delete mode 100644 datafusion/proto/src/datafusion.serde.rs diff --git a/datafusion/proto/proto/proto_descriptor.bin b/datafusion/proto/proto/proto_descriptor.bin deleted file mode 100644 index 9f7c3f26fc0902e0c6cd63add5237fa269f0b77a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 88978 zcmdR%33yybmG8T6-)>1)i`&<-E!#=l>BNrhICd;M&b~;pY%8&4(~`3=fTk_AZ4pWB zsHHe&n3*s@5(rxYNr12h2oNCb49gIB>`NH-eOQNm-v(xY8Q$;Isk-;JEXxZ6?|b>a zB>LYv=hUfFRi~;>Egd}LpR+-Jq&!vLH(eX8POLjPS)HneLHwn-HfZaqj!lnGlqzH8 zDQLo_LF1(TyCYpluWBkqxHuT(lsXIpf1*5Iu@vU-aC3swgR{AF>AEcp* zTlQ@ot&EL?X9d}P@`sVz+&MqVZzxKd9$pYM-7sAq8-;qZ?S3LBp^qevKS6XuKeqqt&Y9Xu`{a#_`HjSqep_LSL+>SF!7MTB6>Gsma5oh-c}= zL2F%7m=7}7R}Nb%%Aa9-kiD@yHeE4=YAPwX$h#n2{9;QmZ%1|i=x}*#_gHzNzdBM0 zdxMs-(c0AL#Qve$aCyR-t&mh|ho%pf_l{Ktpb@_9sZz7$lTYC#K|s@ZY-LzlKu6}t zy4xM4TJ{8ecwx{~tBhG@-!LypYB1muEpJSX{j+1ER5X39){#F_#jB+k)|`q;7hVxGiFGH$ zn|91MO!b{j`=^-C&{+1EDN#+sc#*NHbX;*o9ifpnOEvW5t;%LUik#Z?-W#SXlZS`!$mLqc!XxDj zSc)zoaB>`*`50arG+TXc9IYJcSY(9Mk07SmUQMc%K-Ei&moGBcu*Nq~BhYwbYLqWS8 zSn3+C8RQu)%&5{*@+V}(*%;(TCk{?e)$9OR=jvt*PbEuQJSUhRk03e^sD&N%V{cP5 z%oeu?O+B?6w^k>|%TwX0L2#g48#+)ak1*8BjHI#D#Fy>nLwE{ysF*RtP6V1t@rUBV zpmle7lD0Xe(ysIy(|NDh5(Hg0PFD3>abK_`D*nMqF&HY^@ht2MLOQ7oy7<+DlS5(z zH(8ji?07>XqLjC6?nABkU=};iG8!|j2#l*9GE*w`eRXYU*P)5Zh-pHl%D&2EWn#Ee zYBDVSOu}T&aIideK&yl~g8|`+pl#pim<|W(uw-CwDz(bjsG{k1iLtyxhwnNUa74|O z5)6!$IqSf52oIBOUwu}|QiSIP4dl(>RAca#+0&c`bhNnXb~R5l%nmVWt1*;kC{Ae7 zsAV02sk&Ntde8!eRN+uIOx>ZEjxR%6f=N$VfAQEL;Bsmw0n?al{nTWJ&89mFHpZgP(o%s;~Y&1kJU z3pTJY#J-UuUY3$X5GFQi=8-ijj zXsuhK{CVmftw8na6`#a1)Ga3dybO=&NYx$;68kDs!w1arF2g!nK=HwJFmJ{JFmm5RPe&MxmDKAlxu7&S01VOsVRnw&-(@d@Wua%s*lY7OsSQvN|$7 zTp6lPR4Do(J3VQ&pLb1EO4UQfXJv!MI**o7S5{`GiLG$Ro{_0e(`BXojlLdHkJ{Q(|XBn>RymQzYEHtGbu8uRM zuE{cO$XG&#?xxZLN$iQ!j8V1*&1MKS?WcBP18HD5r7hJ&^XZAb(hDjhW&w+BqYvSg zL4&%T8uJ2aqUR=u>Z3G|b-RqGs%ad_30Qhj(2`6zktmY&$xlrO&54D@tl_*(jD&b` zV?Q_BubcaHP15AWgv_`hl)q}R^Ux9KI7av4)6%Yg*d=AW)D4#h%{sl*xv>T$1N~&? zzDKkv=@2v8RNSsrsX5zq@wRj@U+W{W>@`zLU5F<&X{Hy-BK|L=$}`eI%a+7Kj@4Hj zc5UuFPIrMzpxfClr{-xK-DmsTiP`4ejOA(@x3-K_(&_(ksuWECM4cILT2xVAdaVB38;2;#U-xG=~~=u$%3m0!wEnAO82L9>Q? zh9pLMJTs0!>1ASa!_RBYa|eNveT%e%YJ)0 zXswH%o{Z{5-G$L>c3k8->gaay`L3!!lf*s7+1MfTqk+zpZ|YMi_e{ic*`f#F$ujtCY=zT8Cuc zB75vwY8DQWdlj1-T|t{EYb@b7;s7m%#fexIO^9aLg!xaRF%^jsN72?qxa{Z?)5z1ga2X4dx~TPEqfr$P z1WnP7%SjYlrVzF3M-Q3_X{KcUmcZ03YmP0!{Aj(^dsAiD_%gS?JGz^Ue1=)i6rad2 zeMD6GWE4LyxllZgK~>k03@BbcQ+)QkD4go_BbJjR(!`#sbpmzK3Pu=GSmIb3iQ4Nr zRfod*8CD`%u2eLrhOto^b$QJ0)71rwi6@VhC(RH?7LHOv>ny>_1n4WWhSnfoU1+`A zB)cNW(oGrUi$wUNjWm^@gMD3OA{sjqLRup>BWH8aGOArxrD*J^&OCiJ>ARBusQJtA zT@mDkk9C7|apl#0ygF;aTb;7(t*|RF64nNd!d{Wm>#p9sAOvn!D=#3S-^;XBzZ__MKL`&CcU`#Pn9t}a)MIrkpWOiej za8!a=@-!YA9UB=gPmXlR)>|V6iM|jzpI0;OacJN4gl;YCKHF(Y+iR2EYAI|6ZOZ7r zhMR&$cG8E8&E}KQj4BzNJlun+EOP^-0;Sm}hjrayt84Z;ZAh3fF|LQZgD`5pL(?NN zg{JxF=33pZU)1#XY}uNSm5;dhj4<7%BW;T;5{a8-&rK~-FRN7z;so^t^Cfi6E^6hb z%E*wOnb2*wx?yfxWvWkU%;^cLXC8dXPi$$nm^qj^LqOD8_ucBH$dr!sfr>M6vt!|t zY0T4mD|XkdzA^LN)`~yO-?HU8No0QdV25tC)wQvbNpWpV>Ewt8oquYQBN4j0Hp5>G zl0vz1qc!=93>qQd$K1f}rqvzk=&Nm&BaV%Cp7%gDS+PFddk*ayB;jFWSab-?ZafQ_>gQ%@Go2gUy zG{arj#SM3?Gr7U<)W-FUjb2~rSZ?_0YHJ7IU2O@Cj7_74xG+oM64Xj1d+{|6Z7>22 zO;tNiH#~LQ9|M{?Shcw{S@OZEoTD%cxdYWP+0G~$=DJqMG-UG0D{3n77m*?pw9q;9Y(sAp+-P*cjbeA*SZ_RFJZ(8<*iok~$kB%h*B`gPD9&7BO7~c$2v}CF_>j$iy`i3C(b^O{xdvCtpCy0@}hsNf^4VB z>OrkuH@2$lGxL{{&=fBWasidldw>oW zDKYN8v3ihs_r%C?ZU0Ba;(4kEZ780mwpRt3@?l*+R zJJ^Xuq$j^9ga7ilyq`ZSFw|07MvMlZ}&LbywFL`2MFleD9fCE#1Ix=$58+`nNF%9swdPy zu9+t4v}ta+La0ZPrew$Ycy#9|lA)C?w@Piee6TV!e4wnsBDPZWQx9L{%s^A$|4$0P ziLH&grN{pdR(>O`f+&VrkezsIz9?urbfCf(f&9ld8(E>$t@o}WagcvYEkY}Q$!IF) zDJraymF+lMeWOqdXYn6`MkiCG7!6G3$I%NLh1%txRQs5VibkO}`QKnnW`YzaZZh_} z%d+S@jwNA}Av8O6+8GlF6aY zW&-nRt9&Vb6%U*6$ed^hof8(POax_=BON;HIwd*IC79S4nW~lY%4dAJ`67`z4r+3k z(VU;KE5oA+>6SAVrNA(lzX=a!l~G&koQ#Z=O5EK{JLkxf;Vix)9pn>=s@!XW#dSqA zq}o2ToONNqne1i@u02s!Bh+liT|huyN-<J%29C4J-UWuC;oN1tH{61#ihHwAZx;pM>}S6;@wUr-qJM91s83q5oWw@96mr; znsd?&!bdSoL=qBBi7s{NhGyL%2BZ03#xSdcd0R(`-wupEuA-|=PA%rfDiiys4w#OV zEm_3Qf79UTc!f4Uevn9g(-gq;INRas{JKy|zbZ8fnfxX8lD{9vK{eCbI2Gn_v5)(A zmEqCx@|c`q;@s5msJY)Fc5N-iA7rV_#DFVBGP%r_6zItcyB&5x;G3}6xj|rJ(s5sz zwRLh-jmv(%DSn%)^7uDu*xkcmh#s)5CFiRJ0h0-)Ku|utRZIIbn zK1dw<1T82I9F1#3vI)dWT_>@De3GG}G9u@!vNQ(ncy>eS!WI-dZz>$IrfHd`BRpkQxt1xl&FcE>ByEE1ow^9(UTtluxuzvI3bx<0zorHlBw1%+m3vMSlDUqz0>*@dQbn~j~S$hpA+=^qAE zZw^d>=FqBLL?5Bkrod!*bd8MdXXwMWy0LnFg@})mGR%{VlGPFGHnTFsc?pZvElSoh zB^{-n{*N4GTuqM;7OFvFm!jNs60;|l^m}!kBz7-NhEV#JY_r@L-T9rdwV7C}mCz=dgjCDDJYd>Yb$pVy>~1&7w}@bR zYTpHkDV#)Mn&g`jtO@dLh3#jYj>)9G3R#;;*%Q%{8)vedFf+c2F!`p!IAIUiu-RrO zO;bFIaBbL}B*A6fXd088u5cvIt*I28fs)7}3h4?W#W@>DrX^cTB4L?UAu%5{qcegQ zL6I`%+7vW~(P?9eB6Z{hwg@srP9IAYDI|B5<>G)LavH4&TKA1r%TtjkISJuG)nY%Z zR*ozZCijlh5t);AX3)xpUS%kfCWjrwPR;V!Db^jdh)0Qt^kQ*cFgbRKmPuqNlPbim zdNUtUThAw(8OQrnLNxlpZzeFx-NVZbIxE}I=_*4H3)Jlt+nF0Qu+NJ*RER5VWD_|f zAT@3Z>rBGXMRgj7GIY37o-{7Q*1v4io1x25T;~Wh2mGu{8N$Ix`7NjH)*CF>BH2ihAVB%98U8Ez(l-s}il_Hmq@Jb)<5DK}glzsoz$5 z+l`{;r-v1e(v56$lsu)Zu5~^pSnOI5b5DjgX=ldz_6$SarN_Rbjf{wGcXD28OnH9=I# zC31P8pFRLGmww8HhO~h_gIh1K4}i?YV(3_C2Rph-+j@r#mv-H`xS9;L5R1vX`}(^| z*O{Y>bKAmF${J*A-?hD4h6ef`**j#}dsZ|Ul; z9p*SG#Zhth)8ElIFldh?=9A%Wna@FL z(h1es_Gzefw4aSy+oceNT-8XlF~g_hdfidFXbiF0wMLE42;mI+z+h=l&tQk1ORPII zsmnWbv^1>KvU~ca`t>McU69Izb)Z!WwsnFneLd1vr03{(UOyp?<`pm{Xu~rIY<2Cn z#{%n)UlZ?wR#IhWw;XN43{@tk$BS)2OVYMW(xshqEd1%6RWd+6FVBv0g@x@-HkI4yt>E&Qc@1CBC#7Lv!l%J7Vd{hu_CEzn7 zOL>?`uk~6X4ob|)N>?#QNH^gfC;dz5V8JXe_b@Z^_fk-6s=CV%M;d_6XsDS?$YU{5 zWIF|~TjtGb4R{@oWV(-{+Szzrrbn7UG8O9XMegaHN%!uMwt`;LAH6@*85F7S-^NYOXJdyj%0Mp1jIx0auK;2On9^9G1-2l0Kq8(-{@=l&D zW8H9RMvz37O388h#9KzTH`m!Fez+vToZ#WeSj+yg>Ruib(T5DRo7EM1n@Km9>k>km zmCbzSVq~+t;NXPl<)%7Cc1ZF}8G&I^5tk<4M$~mj-8wru9hlG|eoc{GP<=#0u6)`x zNZmHNJh~xwFcaM79S!*=vv%2anr$JX#}uNfHgw#q$q!fANUZU6#@;gTknp6IE=cOe zryfhwtt5%8=Q(zpMDw;MDD4uZ?v~G1a}6}X?oL}?7G%dOL}={_Wo2@xahaQ*B~NYC z5(1QssaooLy5Bl8TCv7b(i3F?w5#b7qpr&3;i(yYtx*_EXX{G7gs5wcdWU4EMbSfJ;v(qliKh_h zuV$mrUa6|>WFKtiF>N*#p?rV@dk|yQuanG&)L@9Q`L!DodsQf8f0`jA|rWUwf~6w zsv1(Nn^!qW3BMR!q?~bYl_Rop>52hS&&260ZB{#Q0|GM9M>noTL*`>g-e1*mqOQ9- zjm#|yD`v($R_;MgxO=QRNYt6tN#GiVm=#i!|3-H;RfmOH+k!i42%kSJS5!Og6;;{X zY3@84kGl{kJaY9kIS$lCwVi4@9z>Sb@ql-g&5Z)NvZ~|2th~u<6X+T75Cw{^u4;s; zZs>Gb$9E=RrhCZBIebKPC6i>m5mQ! zC0J~>%2*I{g2U|)RcO*SBDFT@HeI>4u#G0+9~W#%DA+FIW~OoVk8Q8(?RirjN@lHo zIdYs3#@Qal;oe};5w~I0dU{#+?Ag?uaf>Y>c)^S-vXWGHz3{Gd?27BmH|qhnbL;N6 z%-WG$=6b<}Zo~v(YI@SX@S)DDF1!|n@p)p+P?{0qBVMq?)xr^O?SJWV!==H}X-38& z^GG7&U0I%NiMo!cD%;zOg=UMqqgWXcODp;RRjS-D*FBx?1&P~4PS4_R(!nBU%KCoxzhuY%^-Chovf5gX!?Ls8 zqUh$SMmxvQku0h(iKHE67>HZ1R2XaX`3V{N2*XK;;X<$zBew!w@s3}QzlrsTuLqv6 z7zsekazF6qMEj_pi*Ox2J!aSTbJs$8OlaND7aW6j@`!tc99%0n3mwhp{?(NEAotIl zGD$x@$4!gXECQKmFtF6*v2^oZg-jJ2c}SG+eevh0@^wNux224K!G*f}EOu2tHOSqni{QL=0Vh z#`C6=FasTKjCt1aIeei^wiv1J_y$z*{R#W@xT`TI-lK7H#-d5v$SLtzZR6@;#vK_< zJM)grtn86*j4#Q2Bpoburq$Vl8+FWbi_mCd>p~y=v=?fncO1usS}bBN)an~*bE{=2 zPkO@f_rU^JlEiHGBwESI-Mx8S++Ao6dhO@Lo5RWFy*+jm$z{ojm%VtSd3~GXS1!oF z(#yV(J%_i6*6#L+Y*%hwY#*c2%{YBo&_rOYVqT+=*r~jY>W-<`g;k;mSY<>Q zK$L2(L|IDO;fX$)&&zt%y`nX5=2s^|md4V1YoN)^B&2j*K!7Q5u^2C7JP5P~M$x&AuGKVze}luvL;1E|Sd z%{^6X=V}%f56dIU_LrBUf$gu-u!`J$cB77lrDqMxFk+b-7-lz>5zBz$V}qPFKiSht zbb?ufy(+z=U4WB?$u2M#gAx{pgVwrj$>V)cK2g^?+Rstf#d~BTAB{#)P5gONjHAw$ zqv@`$!nlzqQw=?fBR!pKhw{N3qWL~|oiwyUgy_#wY{ol(#}ivhzVkQ7Y!x6Q)LCk*X?w#7_jjqB^*^?iJ@bJd?q^8f*Eu;jQ{;Yv{=_R6?*&cLD=2-1P#_M=9snJy0td8I0Bjz=Cn~jM$fnukw zGUIA2S;VOcnb$JbXiEr;(7L^$L<=-CTeIN6=v#wU6JO=+7v3o%1Q-#{}V#2O~}@Plf}1s#shq!-4)h%6oW#Upt$9 zrueVpHzQ@FC%E5g;rXS7cKf;#|7ev=zNP&)mfBrnG`S(I_`GzmOiD0g$2#ik{|^gP z{1!pf*|)_1N>k9f>7{y|x|3_OOfTappL(5RP5BP<+ZMAQV>zj2%Fi#^pDi=zX5zc< ztz3bXn>kbFM2xxezB^dzvW}WWbcp3-a_6D_#cl|aMML6ni}*B_Fm*q|a}1v*=dt zY)7=-aKCEAj}iy*dO?1Vw}MaAAF!Eix$E*5`n z@pG(fqPD8xCYij;4;mVga#obTlSwc1w2M$79*LG{3$Qev_-a%C{ImZQ{Y6r{L++O@6K?>V|u&< z)aQG~qtkRUie*aNd>(fvurHqtxsYfWOkysACbePB89|%)M1pw49pooV!d&3(>L*Jw+B4ACzb&6$ z^Tg($O-=50QNo5G)3vvznsp6VYiNc#UA55(Rjg~OJb_{e>8cHnj-nOGJ(bZhG=jGW zj$9aUk!o~5=k@Xp@)1XyZxoiT9PpdWH;F1cCh~!#akn7fENT3);oN+Su}F1)XTDWF zmgJqMe47Xy7~M~g%g+<00kp{r<-iS-Q~CMwX%MwSVd44SiQ)VL`ICbl<-_^*a9+?{ zs_bV_*ePdW^9#jR-J?@G%v(YEMMBz5NM}61I9x!ml4ts8@s&xN-XY?94ov2kh#DA_ zSZIDJudOW5zpojcIxrwVQ(h*-n_niiBsQdp!d}C7aZ|f z&iCdopOrg-LpGd(EZ#Yoh$b+S56pzp*%8*N%AEr;8warb&|^y z`2n%oj^XkAp!~6IcqG5a7NmT*3sccquZ}+0u5yitFkNxW=y)xEZ3G$V$MV-j>Bpk;wPDtj(BIE_-o|u?79{|%pU`LcH)Nl zqwDHz>VO#O8}eRzfH(x4Um}sH=YqBLE2kc9j?cY{IpGg~Bhl>lO%{F~R3Ir^diw`@hYa?l z2CQB5OGcVn&z_yVrVgo8e21}_j;%Yoq!Q`7J9@jeP=PemgsxhDv7Xc)()zKRDM~(A zv$5`xMqCt=Vx*z$fKCfgYg;dRVmM>pfxNe-H)z*5vpyaym@;}3~R9@rQhBy7zT@X z?HSxf4to>78EClC$k2A}&}_DH!+r-WjCbbGp`;{Fl#+Sej$S+ggPi_dN8_(qtTXI2R2g_otHBy+W7C1Ci=rZyP z1J!*~hq%aB*eXrRJY`c@)itnnbpcqJEb!K1P^eB8#@RM64D;m3Io$tgR~)1}YUJynokVUr%p=XfE6`{Wn}>eu&uy6r;7mq3Y!Ig?$JrkBpd#D~}aM zC-^XKln4qEDi`;^pKK2vHrrAKe%yxX(Sgx}%U^KwsWVeGroz$S&?Hu# z*uS<=vo&5{F#z%i2PP+NVv~u#l)YDn_h~tP7&1a@l-BQ7oCmg8nb z8~}04tvC>b%bQwV8se7c=UXq@7EeDCSG)Hu!5a$&_b<-{BC1 z8hy~?Ny^jds~LP_e!(Vrux<3UVN%W18&BhHR>KC^6seVgZIiE6?|V{Lo7xswwv13Na%H2g&Wm#MVLLC%O$>Bi zlpD35IWNkM=Dyk2zT|sZ*f#quR(=+?&8<%5ENq+UOR6M<=SOTggB)89w(}#l9Bk)D zYz<-N0{=`azX7%jd{>$V*e+<-mh5{Cuw76*!{&xpxG<`>M%XU&wL$sDja<0MiEM=J z!n0hxHHDdr{PS&YO|V_$JCiq&+eN2raA~kzw25Qa4gQJC50JMXjzwr!D;i(uQf$cbD8+qUAF z)+CF=%yxgZt+&OnZTDT{T@2gy4)xN$w-~nVD_2>zjxf^~waE_H`l2@30b5_xCOcs3 zi`wLpFmq+(f|kH`WmL8$uw7}#BHvpA+m)yCo+*Am8~XjJN9b529;d%iJ5*M@^)64{ z4**BC%Z`X32zNEA#{nU3*E}7~u$oklkml zFgoQze;~C-brN?r(741{CMP-#+Cd+H@IfmagocC7sxJt(L3SFX6M_&vXr}-Tp?^*4 zkt$rA-ZhOnqi7J}*V=gv0CCrPIU@iB;k6Aa9E7-Qty67~0$=B8wE|$f&dy&zlGdby z6$rNL7A`VHYz+NJrG``snTkECabd85!L$*l`53Qt>59T0yPDZsDaeDih026Xez_e# zZ6=487B+AONIYg^6N*2kS!)A;v;<-l6vT|rM|3$Qv$2dX{og_+VC@lWZ4gyCVyhAa+sLwW93|x(IhSX(5Z)a6`%^cmaB;)?XKkWeyB(~?pR<6gT}L?#;J zQEoEP7;nQ_jE?FJ^pG9PW0`RJr~qs~V`P)^!~OtVKDtXYQ) zpl~%i(19SVwP}Y3A+px4>z`(i3CffmLjbT%*|8r4+mv-XAlRnt7}D%9L7BG0Dgd@= zJNAQMo1W*&EfbV!JFGT)Oi&Ja7gIrG>g+lf?9IEuf7A)|0$LfVG(hL92_Cf&s2}I);B#o>^dg0?e9VP*2_jub2 zL9jjE_CgTaJ^lI}mLDX!{*VDCu|7kXk$zNH?cxx2<>p5aTAW(Lt8C zH>aBxILHd`<}^)rH`Z?rb5BaAZcnF|cDvP7!7Qf;J*y+~*iKZ(I@Vx{)y2 zqy&hFEL9}@QJyN`^<}3={9?vuhUq^k-MB0`Q$SPbKRG>DC5ry7R3c>5l;{saL=v(v zHqg*gkNz!bD$>wOMG9Q#Ags5fsY;tlS#L>Gm&!`wt!d1wiBzUQwM(niCJ+PLR9J6K zTMM^RpZ;xWDpV7xP=RV;5@Ee9O_kbISZ_;HrHBINSsjxmZ&Ag(8YHka2Pfw?wO)rxwVm9wT zJ&mUkscmA=XQXN3!UsYjAUjS9p?yZ0Ms6WepOL1OD=Uf5OnbZ%ZfKcM3DlysNoN7t zq5%!@vgM8#NzY8PjB67maD};NrM)}T8BG>v=szpg5%b@XW?HKmF^&mz8HxGtNH^zQ zDw6L=FOXr#^XG-RyV9xW+LE&%@$X7Aoe}ltNy+baB?qA|P)iPk_HI{lAX4vkC7&l* z-jnv0nJhuD0v)Rq^`0~lX;GI{Sno+MkukvY^I`7!>C}s@LM(Os=cfs=h(dW$=w7D~ z2&q7o3WWAvrw|aS_d130qRFC4Mv5thPug`HDk zxEd97T1d4aSsQHL^qLo?iCu}6fN1feG{Gye()=*@(sb&T)=I4G{FkO}7-zm%={{#A z5M=|Zm4MLR=d1)o>V0A*X=d}KnY}FS-EW&280wd$8)d{NS&aDdH0w~&2!y^sRUc?l zo3&PfNPfB2s<2|USEN}ODXTaLp!yaPVSPoqT^%$K)>ovL$=nXt9p+x0PQBI^mDQ;K zYFE@yiuyp>TWzF*s8ygU1SFFOT&)6OeIUI|dn1rc9!Q@hD{}&9qQPs@p6UmpXh3yf zK$F^}`T=2mjni*In0qjtdV|%EWv~CBco~tpK=gaP>jogC0&_-PAhfSfH>kmYNPWHQ z2JK<)P3hGCu~JzT`)^7&E)Pz_J+(7vyjcc~`N{dWTxynZqfa`yzS#{IAefVonlRAN ziiU4VdpaPr8ba-2ug_kBu!v{K6sf)LzS$f%2Sl^ar?WL@se~xp_zzS58w#y^{$YM`fnFRo& zTxlL}k6D?23)I%q?lA!eG7DB#3G}`_W+j_T4B^B0prWb4XYxh|GzALsG({F*!YRtcZk=2-h z10$=kX8jj818SEkxIo9s92{t8K%~O@FERsCg=uc@cAm4{Yl0Q%Sea`Bn{>=271npB ziP$JB%hQL_-ezlv0ILC=)tG$)nF6bsn0^CSoa-Qx9!hUK&q`t~`kuJzno$Diti}`^ z*q{SkyT=?HxWKiwme7B%o7J>?%)14;7S4~Q{aCt5^#daHW3GiRk}N+Svx*l5YBiB)Qf=b~!us); zm9jkSYIu<;3s9{Bg!N(9If1Y~tew;I7l*k|rc> zS%A=fD&3@Q0f^L3r90GjFP1Dn?aBgz6{uwanp9gBAgrHuWmzos@)=ha5cLAovH)TI zj4KNe*3Y=IbcDIjr&C|HWg%ebe?HwPGd17ukg|Ls%`#dV6$q(7RUQcK7o4jGBJ~St zyOQpZEWa4jN?Cwf77|UW?LI(Qzo_#=$(6Ev$(02}u0Smd5Y{ibvH)TIk}J!SF!$AT z>RYxfL^1uZ%7j&huqF7Ef16_nTOvc)zqug{1alIilYwHFC1RJaIlF++5U6$m!umC5 z7a$sb&Dmv%sQ-1>fk3bVwF3c7s-4>dVg0(BP%aU>e8brVgh_#FQXs6~aN`gV)^E7M zWQm|}I%f=m6{w982rl$QNGPM(;f4{YR15ROw4 zWpi@DJRc@s%<1bI^UT`RI`*B%c+*Xe2n;-8M}bFLI5;snbrw_9LsfRvIVvG156WX} z3z8I=O>W_o&BJ}1eVnTB-q>2%&yLR(m>(c3OmM7vtcI|HEQ$$xnxinRej(*gJ^#XL zm{Z18Gb`4`@KVb9U3R-o179i?`8~IY1YsAT+64&h_uL{9h+V$t7LiNE-rslQGYFpw z)K&_lUcc`qfo1)`r-r%Tq*MQC z6*?8l-?$aysiM$-IE6qc1XP89(Ef*02#D1Ga0;C&3jH?ituZzLQG-COK_HTT>uL~a zh?i-Q1Bj&GrrC2Ae{ibw%-^|10SHMzCrKRG?_x=k?eE;80AeKlP8S89e_ELPeLD5u zwxp*)`Fqz^Pm_}V!Icz*RG^j=2<;zSNr6cHgDdH2lI0&=TLqyXQ1t^M>5oo7pdq$x z6^Nui+P0cyvG%8Q>Nd|rEwYm5pVC>`@Ak8D(8Isk^GwJ{5Q#vuv=oSmZuSUvC@qOk z@VsU*J&BSf(6j}C&_2OyGHVMU=$~S_QWl_-tErJ(lzn0>R~#GA$;}|?iLqR)@FdSO zAtG{-$vDs$MIf|K@>*q2Sjt9YeR51I(`}%m%|iR+m=<&1;&HA+%O>+{pet$)+FQIf ziMoqi=GV8zv@)RvI@$(kZ&g~4EOSrwQct(07mGdB%bKZSRu0AZw|kUKvNY#l1o{pl z=60_^4&C^q!ud33PLM)1ClK1FX*GHN@-X*IFZEo_(q9hcGd&v^SuR;V%d_DY5QPS6 zYXn03EYF5pfK17Ur(H(wW}KtpV!l*^?*KgaXV5qqM( z9DV`1TxC)B9M1;TNJY|fyk)B#F_NC+oxN6!4=?TLF3($M6J=2cbduOv0Y;LfmEGkn z(@+DfNV>~gE8Auw3EI13Bg&!# zdpzC&(Zb52?jFwuMhZmAywnS9gD61xe9z7m3(_F&bqaxy3RI~;Xzz8k3PkF?s*vZO z9_C);rCwsCo(|=UJa$>7n5T=>7kg~gi8de%22_Iq$>hb(U_e-3?6F5|iOJ-}9-G86 zs1?K9eO~GnHj^Th_jxwzSd>g&=Grm{sX$d72<^*UTLvQaWv(q3rOCbAl^O&q(6LHe zez_|(sj$A>mHLb@_ewAII;+qbP`=WY`V3L%RZc1hsX&zqg!WZVDiEo!5~+{GU}uOz z4?w$ghdC1(#|d3vQ10O~UE)MxB?=N&C(hxr3r8ZOK;cMr;;gBHp)F4wR(m6xR)%on zEF>$F7aRLxZy<_1;IXs6-6%p=eJ%ZU=|!^yEuAvQ6Qw-E%ybduvXvsf*0WJcQpxtU zo{dtT8RlN^rQT?*dM1>w_iSkFOtI=4Ts4ERDp0Kog!T=tnt@1tgI2TWuLyH*_EP_B zrLKVT%_4O<>xvbuE8gM}8Vd{8#9Pzc(kRz7Hnu_*7H{$FRtgC2B*aVxN^@T!D!$cK zJO~wmsv;29x4Mc4qT*X!uU;Wmd7Ed$Y9LsFx+Vdd)I}Oc1;Y9^k7H$L&^1=w$R8U@x7kkv9zIJEvqu5 zkbKvm$4XPk_j;T+vZ=^;uV;fwD`n_-ACp^~DE<;a!d6Y#46o@oDv(gMGAM`j@WK)d@_O4bKfw-}cc>e08i#e8T zpFx>TrVK66X(g^SL(4}zPB^Jdi5GsvBb>a<$fR$6oboMgWpiL`tiXBs;p-!7%g{oq zv$hN^ANQJFab;-vxNAu(#WW97T$>H&1qC`I%h2+$*X9Z)L(9XS-IQA?^O;Y?3d_&} z)Q(Fcte=oZqWa6w@(IuE3Q3zGUiitlemFNM(AAH`3qKjxkHiZ<87oX5{1nZ@%4KU_ zpt_}%vNsQGbrmD=!cTb%HPpD0-Fg4h1avH`1PFnSRRV;c_Bb7>3bR2EWMg0Y>PmL# z{m-y`vx#ic3v`8(0O4o6`L60DK=>Jt6MD)@fbg@-uPmzs2!W1O0)(ISI9jH;N`UaQ z9_Ip-wKeoV7n_N*gaUOPx6+fX-p_gSG(Zl7^>f}5-5Xr#wGrEi%i2bR0qSCxL|8xX z+2}bC*3ZXfokwiP^VeFHI8!LlWg~ldU+@;|AidJ#R3UJ+9Q+V7<%#XEvazh3D-`JJ zRd(CH=;dA2ak3D&>{Q$D=7;`QJpWAkoj%(%TOZ-Xp%A(1m5r&d#Qlylhd`pktBfuo zp%~BKuyko5dVXlnmaVgilrY=xg2*jmEF!D1ksOAn>b!6mbFZ6VE?;X@~64 z^K$})qX^}^q7b@9Av-tU^cLxw5-AA%rngF?_A9;i(Em0EQqGBWj_+zg{L&rc^f9x&RaO+BMDM638WiEvk==_`nihkm? zxdyNl)}KhrR5L9L{h!7icp0of$0{+LpL%Vs122R1r*Q{9CG>yBq}M8Z3amh9CW*HE z%$w(&$|-98Pe-YQ~azZg4N0GGVmct5kWtCOoFXJ(HIjq0*IE|#a7DE45%)KpZ z0al=Mrv+Gl<#F^`1s7obmB-mTrN)Zg2sI;dg-2@uv>T_!*> zxz%NIHi3>z>S;EUv!Q%y#>Q*UmP~GUnSjUysF?uCi%snfU zdbZ7EEtJo4=2|P6+>x=N4G>a++G>H&-XV7zrRf2YdPl~FHr7fbxie!os6ns-wXXn8 zD#rwsRT{~i8M9UF`R9bWyE3VJtU~8Nc~^!zPtt175ryt{3W1OcR53tk?{*3Sk$Sf( zhqmc5K@6E6$tI~om3!FpYNou4|6Zfq+V>Lu7~o4 zPS^D!^+ir92&q7o3WWAWPAU+oFLF}P<$y^h^)f53PLJSr2?USz)1xn^#Lb!W0-qgCiQwNbt9Cob1i?PNPW;r1tArv zQi0Gu=%fOX`k<4#Da^ewlX|n2x(UiRW^B-AlSqA&lL|sAP^AK)eUp<4MCzNI)bqmJ zTQjMDwo=c7@~xRh6W#UC6RB@=Qb9-ss#GAfZ*x+CNPU}=x;f0fBa`|UD|IuJ?{IeA zEK=X;q=JwNRH;B{-|3_Rk@`-R>ie6eTfQq}&lQ4j`#^R3K$F^}Log85cV+Be$oXOJ zp-k!nR-yBud?>??;;YiM%JW5|_hr0QOP`l6@Op#%z#KP!%^p^j+nDS`)e8G~ctdx! zcvOYWD6Z^seV7fdc!kZbm)=6Q*LtTp#yOM5Zk<)Q25s-nju+&j^6&xn;VNAAjBeeU zoaIjPS=EDQam!PD4VvO9Q8j`X?|sfwl1jPWmszGOJ|Gr&UuLBo|CUmc`2LKIl!7oG zP>lyPsdmf+!utM<32%G;1!3+(nbb$D@h*V!L$2jrAh!Fkt4$CJ0kt-P(0R+wY3!(g&>m?V8)Q>xb4j=I4nWqvPsYY=yYg-_G@yDLE8gCgRjT>N|XTT?Ar?M*E4is zr6o%6jaaUP1%OU&8?@hubL;1vk*qwnO{fn3e_i_iT^H4zj`qnrWXvXup@qn#zbLS>jcE(e0v&Au+F!=Br?Zre>+N)Cfv)YG4(+ev zdMk$huVdOGv_MB&g!b1l?HR0dk!wQY=r<_z43SfFzTBt zIL#2ZU)kUQy7s#Q+TX_QcO~Z)V!5&}0CaK*jR7OMXNCTM#tlH$;y~ST_q?;9{m%@q zXR6;>#X>!nE6Ze{le-Gq|BB_VW@R1=lGQHI)$wX*e;?QJ8kXWQtt?uBj&=>Se~4+% z=Bz_pa9Mi-U0s|F?H}X1SR4BP9k&NrLIPcTSPSic$L--9*8H(tS=|Ah+;gD)pIGiX zR`szRWX%S2c321PpJF?#=TLuYivBTxg#V({3Pq z5Yx)43Fv4yK>JTIZ6^T&E`HmINGG&F*Ec(%eWD-vvyB|8VCc8BvcdtHC=`8uBeYNQ z=b4>f;3f`L#5%~j1?Y6x1nrY!9nK>X5!1?Q1n6kbgZ7q~b~CXCKWf~v#sIpy*bMEh zel%{L&$S_6*9~YS(|@4r7w1EJ8@ESn`@MjBLR^-%Ws})1&;+bty#U&$_!<`jUPw?Q zrj;0-fL4 z0_|OXG!FF=vxyr(FSJ0{&U&G}J8oxNIgk<4ZiN=;XtzRpPfWWl^q(8kZi5!+XtzQ8 z+?aMd!J)X0w?hkbb-W$g=f!p0M>Hs=?SmHRX#1djeoT8MM?K<9uY?xpY<4BI_r^B6 zifd0X?N!hM9qm=nz96RELD(s#-2pAo(e8lug)!|;;!Lr=JD~+SeRo3pqFCR4PL0I0 z{m=p(Z9lXxj%jy={!3!oUC;s@?Jj6v64UM`pcOan-OvKvI$$@nFZH8!z$1uY#ck&i z&;niCc?7ig#cij=d6by81TE0fmY{uEOgq2N2*Aj$_%XTfaKv%YFp?!5+w(E$x#kAK!3v{&CLHj^V`$%qH#X39^TA~H|ucldcX4viAs zjA=)q1v=VMXy2){o_|r8d$*r@uZEO-nLWJQZ`5N57fDFzAv+E6K}1%7x}OMy_91`1 z?wtaO{XFE`)07uUnCLye-BJP(>;Y=D42Y!n_;yPPXozjJ42Y!n_`0RU$&=js{M0vW z$V(zh@AI?fghe(Z`n})T3q&GNO%0@&@8>xaGo8tZLLZ1}B}<^Am5|p5Vp`A#V_IPa zI$8;NeK4j)*$>6Eq9D-GO33R&F)dd3uxlE`c%TL9kOYMG!@do9v1;S+j_cAOXn{J5 z215H0UvCj&2h90V*WW?V0=3x#q5Y_DPZYDNARg+PG6-6rHaQ@)AM@?0W>yshKwZ}Z zK?~F_4TSdNT>G{5CFJ#Rte}Lvfa=;L}>rjP2E{+aq7ppR}i#7r-OvNKIz;mi!FkuaoHr~1=KD=BD9}! zZiU4b!Bbyv@uR(jyntrsUm&!f_I2kUNXY9m&b5J{1*&TULi-u#+6ZnCOZD}F0h|)@ z0-EDn0-^n^&kI#*GeTaUi;W~9FQBV833+|aO@(Q61W#j|h0p?>%|d8DAKQ$O*B4?1 zCFBLv=>aQ#Xusg52N^kX^2J!LguH-Gu7te47|SK(^`%&@guH-Gu7te46w4*#_2sy1 z67mANvPsD6%W>HVd3`08D#x3Q7TvcYrg^NYCLV3K(Ev3EF{J7RR@)Rh)Xi_~CG1hp;^H8P0`=LD7T`0<9 z%SG9rsqU@t1geOs@dB&dbDEsy)luDG5lv7ORa^&_c-z-}8*j@#u=G`gir$A_;B3W5*sr_%WcF^9qFZJAQ-d z4+3HRj=Td-8wY~E>)V6pAaVs7lSv}1-}UXmbD$wM2hW8Sg}>)}t7HZwNTJhT&PjeR z)?Xa&_k6pZ1u>Go=bP;;&%Y$h{m@VS%-UC0y+8DMWJ>hAMC|(`TTOx}8qlrR+fN7E1fd{As48FI}qC6yTP4# z2hqwnQ<*dXb%H@6w103D42nUt(pnd*$fNTUL=dfvGnGjL(AhyI4gVe6 zfl0&vxIvhThZd*{k}w)o|t7*UQVW8CMVOMl=YsH)syL9lAn~dN1-m0*74*l zk7J4-0bwMd9@_#!`{e8*-3JF!jZeYa zx;?w>EJuu_+p}x*`0r)X44;;@jvIs|ppztL%bylYl1BQptaaQFBk5^k|4mY}(nz0? z^_DMP$!!Ap#TYL4+UJIQ?T@C(8|!j-;?lzTymqKnEN9SRGYwRPki|2yZF*i5NEXk? znoH}Re|ea@Bb&P0wkwH7-jTJhFI+AS=T2u#5K@6^Odzy(I%5KndZ#nysjxmLYabK1T+m&y z!s7jbj#V1YU9rN_aPCrtJ^zX@_uOpih1LvLK>6IPJ>_?WnBjS@EFj7P)Up7feO}g< z1&Gw=xw2d#+CJYY1VSO8Dg-pCwmAY}eZI5c6=H^av-X)S5UfDQDuVCL@{FFCfmB%U z&6;Pnd?4rrS$ks;gu*}_u7I$gCo9T~NL_YtPPgi5Xtv z%m6|vP|W~@_9e~?K%~CJnW0OxeW^18h_V2+EI^ZL%>ab;rOpgpVut&i89=ZC9jgew z&zXT#SnqRY=o0iYX9f@o1Jw*bSYPJM05rtb4BcVw{%q=eorVuXJVr zAr+`*07CmpX9gfrU+K)yE!w`ynE^yufLa!yNwsDG!ul#_hHf##tDPA@umT;c2!6FQ z1F5jS+L@tS&;!m4AQT3w8Gx`p;LHFt#MTTwVeWO=)EliCdZ2ur>l8g=h6i0)Kqv%M zg@DjL=(-vZsSmoc^oX{v&)TQxK)6Ss`Ys@nUY~8&89vYux9f3gAd+66wNKIYh*jQ@ zwfDb3umYVDlFu8myeckzgj87HkmdfDT#ekq?Y3;{ZMJAzpnS6{+7>C=Tbxu7Qh_QJ z2<=;(R3K8{qEdZ-i)8uMm{rOGbgWXAx5lhembW^Edc)k?v#EDkg?gcUyHluF6nclV zH3+Fdl?sIR9nRK3q`t%1x>po>XUr-J0nH4=9?}=GOA)qQmqDi$10bzZQQ)nAevux@^ zR-tWBzAtOfbZ!%c-tVM>kP1|VfY83*DFj67`<+7DM4=C4HJagr=pI1r&p?yfpp6p< z>j$zLOM;l@_ra`vUkd~)(6Nf(4`v(m3J0mMelTlZit>2LD)*6W>R~Ml*Vl=BWwYib zB@VVxmXEqwAc#bukt&Jg`O&PMpl2nIk7e!b5~NTk$3SR5mbKA0BD2J{?4$re!U{Bg zK%hxA2g5vndzkyzZ0ZZv)Uqx1udeR5i+Z2T+7~21m>Q_11Va1C?1B}h&jBg)C$sj+ zi0zW)r?Q?-H9@cf9jhq+sjR&{NGhzK%5ur>dmb~P?J~#xY}WgHHna5eUZGe$C=rkH zSg~+@nWU^vKS#Pyrb zJ8!i-?jnjEo|r1%Bq~ntA3JO`;%|GeQhrB<_X_v&vn|nq)>+C|rz<5LzFvL>Wgkx< z8kKKALoo?zc5d$MJa@x+>km{9oikNE$2?L~Ij1~vjx*Xh<~11tLFX7d@moUYY+S8P z96M7DpLK)&c4-!$;{gC$pWckRAm3_`mESWFozLZV&E;&m>SLVqK>q0_8- z`XtM5x^Wr=D^MrmK$B`ONdaN~ri|0yl}CrJ40GSlrhb%7cYYzg{xAJcP~eyG2m#7Z zNEPIF#A?A`I?MHXsaiI}zn`_&JgyW|{~&9_V<6@NKy8aa%=d$=eNq(&>kqQ?^?Di* z^Zg)e13_1c<$vg$3kX)At`mSJm7jHyxd0H>ABuC4xxiIn?kCyQZ){VL4fvmAxoLko zZs#h|?`O1BZgrbLsQvvW(}7e=Nbvj6=!^=8fS+aUt8_rJ`k8Ib$RqLRZlD68B~XVy zph>mE9}w1`yMgK|X}-V6+Q)xEXG`LS+3H1EhRSF1JpjHYH)?a6Br2t|5wX2jJVeYrt)PLGak&_O;bpeeXQYpW4Q*aQL z0Gd(H2SWQhX<$;-K&1Xor{JEyGtB)yoBD4nRnA2G-nqJ+BJ~e$o(w`)pq3g4?H{uC zofRNb|B$sigFD6ee{>!KghD`V5I~b^gQ!4Q|CrS)P)rYUf6Au*DW_3AS*ZUhYabVC z5QT2esRmgPi9n5J0cj35=j>KsgJ|%CoZT%4DKrxxSj9^|A!oB}Bv_P7J;i1zv8*TM zY?h6Z<&$&P6N5+u>Kp-xm?!7#;qgYv@)lxhV&^PKp*nFOw72A}6K|BZduvQ9tUyPr zsSz#qxh?=c+=UzdOv` zn@hdON|lpD_vY-9e78t_fs+bCDo~{Yp?!gq3PkD)Trqb`F<)r=jSr%jK*uV@d|{3N zh$uuVtS_|P$bUqbdr2#9L01XM2%g!ZMm7OgTMQeT?0 zvCl_{Liag^K(GQGt0;6|u0<6h71sNlLZvYGid^cIR-qDJOpR*4^fpE(} z^=&{hxj$!zSs<+U=j^*sKr*>McgC4!tQ-h)ug;}jYcr9vR%%klts(gPq zIr&WoS~)0ar1dV^=M%L-!GXrMyY07nz2#c3)%8Six?V3Nkc3MT2{WRZAp<0Y3}gh7 zFhdBCgn0@HBmo|y2w@%#Q&0v$f$%=x+Iyd0T+i35|7rdqpIfze?b=nps$F&JSHCOF zpuyTfUzrWIBQBK;x;%y%h(ypvGmuB+@)*r3S+FXG8OSghKNuwMsw}OfnyrI6*;QHN zYWIN-iCvZPD5&KRQjx2(ru`rZ;b_nt4dRm3;b;)i)!DB0GB`-RR%f5G7vB$(L2EMK z$%YUGts{Ub)guKE(KVUxWFMqKXl>?OhY&`9VT1yQwY3o{XKm*5H<{72HuDSnzu(EO z%^Ej*O?AZW+KgWnj-aOBS50qV930ZicX#yVWxIlfSN!-0<%pwM=I{%$z8}f&#>b2p zJDeY?(*tyuXeqlcYi`Kw=Ng#gbAjjU8waf;H znuBRFYJudvEvu|hkV0>>LeVUX)@QB%p2jN(Q7}YR^Yt0mjA%3?718xs+DdD-4rW6l zYuxSj>d@iFu=iluyD4kl<@UlPZwh-4mc5&!P>4c7D-?V*O$%9*BXo7ewKpUDs z@@~m|Xado?C5EOSsiKc&{*4$2QP9@MU`qANtUyE`&C+F7&DM`uuxE{D+#nrEeInyC zTpD$MEQ6l(m`p@9L3`ps@;<4lP|gL>`eY0iKbApHd9+EQniLFC8T6E*7Za61Pg(G( zQfbnsW1N8y1w&MdpH`^+H zsps3HkJiVB`MQmdn6^Z-(Xr=9zKPQ_yq^o~_(*g28_j8L$|7#;Xb$yMF*v*Y_tFyY z2mJ%baNcKZl4C&Tlg!*FJnYCZN1wpYiNgkl_Sx{O@9A=*v5kKiMsLEhF4A~gV>l$0 zYHZE+u-!e73UAH)hvc8g8!u*l|0RSbFf^$fyckmwsVVcWc0m=0rWdnx9cHujQx@x4 z<284kP7uEm{qm>s+^f+IAQ}X;1_8pk0`xU6(WsnzQ)< z_e=l4FSzQ^y;=~wk?|UnIuC@_9g&WgP{UoXhP$`2=GnPTCos9+QqTLYlI4_lveqa0 zw35Cf_n$JN=iA-cS#RER8=`;AHkp$icvQM|$+7Qberpir;hlFfzcr{=j{S4ycNIZ6 z7PJuvOsQ?#5C9SVbLPM1_Uie1w-(j&1zMjW5z%+EuBe``cWY7Ty%=qKn;J5~5Y>?R zUe>nJmeiElN84V_`R~`IYRCj_v?USI_v=zMWWHaQO5W|6-;UO+U4CJRYL|a|JT9an zx;@6lUWFDP)S|lD6bw=Ao_Wsh#wJ2u<#^v2o^}Px(M75uv6gC>UX_}6T2%MXO_As~($mK=+fxx8 zvM--i=a>c`jb_Vr*#7(Z5Z*slAU8N|mj!n5smw4S%2{eJssZ&Mf6As=SynC_`{ zS-P<9)Y?pr=}yi4oKJ647uJFCZ0XeQ)O>e~{zyf1YR-3XbhtFh-tZhy9}g=X}N!;q_@do-_vpryC6hCo0LIB zPs=}Ku@i{sY587SbILl-{+?d9dIz6?;S(JNK0U8&wjeK}r`N5{QQ(=iPj*8T3{jm7 zo|$_@+?y_=n<<}IshkX+m3wg7+x!TkV2J9V@T}b9L{cerR{nQ(qg-#3gTk}xx_%T< zFhq53cy{h_B6$&=UDuU!!)NAv?bn9d-4O*tRL6+V%=xIDry_c0ZpW!{6UT_>)S`PJ z3Wlgo70;WwT=Q}s&-c(OTbZ*Y4c+E|m^PQi!_VGkr zMhC`&q+`GH^N)WvQW2e>f8OqM?$u>+T3$MhDt5t~b50zc~NoS0WYB z#rXjTx`%mVe@ShyE~5i&`>4067x}ktfQW0H|+r}$MIB;Gqs&D`dQ7JyJ7F9TKoz_aDhbg@Yc2Uk|pQ5ThMO7E)&AU9Rf=RwO zXZPb%N|p;Q$y-DCI#|DcNIURAjg|)<`0a1nv_J-YO%8jr2t@pn-0wyOvG08E@NKb>mz@u@B82S_CW`P zLWLY;3Wc)avV2#2X8O`@#$}rA%|O(z{3{0Ts87EOktg&i$XZz&s32>l4E$y?kRa=F z9^bw8*SW^HL}~|5+A?IUKB6-As6+QnDf{ZDs(prs{rWKp9Z{Ylv&(Z|H1ws#?Bx-1 z^r^F~ia-ZK6bw;CW~=I|D>7RZfli;?bVZCbkYR`_GP|NKRgu{hb*V&VSJtKKR3;dr zip;L8OVz2&E9+8;%&w|S)y=?Qh$=F>sxDQL*;RF^L}sgFXz9~OdxasY$ZU08sv@)1 zF*NomGFy}Tul*3BV2CO*Ta)|GucRWnCW4PXMP_SjQQZs-hNvR5wY8`sv$eG-k=fO? zsBQ)ZLsXI3)wQT1v#V=SBC~61H|b_zFhmuZT~l{KMP}FJe*bEpUVyqbZ`tk=geVxI z3bd}xceNz~sfb>i`<vP`*0ujBwE|mc4hTN~H?n?m_7^NzJx*^}yCKOT;y&>ZV#$xB1>wixNQHTz7xn<_p?hN?%g})Xn)WHhF@G z-dr~h0n{yZsk+So-zP;Di)NQ_CxJd!jZMpBUlZxnV zx!-Qxrx&Hx*QF|e0&O>qL`2u;JBPu#&3AoWDgo4nh`;+%00r9O8bowM?gtS-L^tGi zbq7-p0o3gg3P6+!hNuFl+jIX^A*qPoUYAM$bw}>I%zaJW<_p?yQXryt?#2B%+)0%7P+N z5#5yAtK`&`0BUnRz$kzMZRtTGqMP#%Sx^Kby18x~0;oId$|-;XE$HZLDuB8(=l3tg zDsGcfF=?~EGug`R_s8~xc4`|r2+$yLvh{bRU#aWwxJ zHg;_P;d}Rk;r1i<%Hx41Rf~FND?~{3HBLRrkCv75ZwhrxN&*Y8gT4YWCtL`1jcpR{9rAfnsyuYS$lM6C8&3~EEu z2ZF#TRk7M@`L4EkLMo!K<^I#zuuk?y-uR>Uh+*V>L(2p$j)$qq-^~3@3-rc@u>K}6rOMOL$QSSNcYZ~WN}I*gp}n7bTK|;$VV1)?*?W281J`;uIp53u2cg5I_5Iw>J3wd! zO)E&=_jCU)J&4x#b3gBJxT?8541y2^LsZq=9tM$$==LyZcqbcQG$t3e@jjfK;|s6m za2YhA@PlR$T0zqal6OK;TH}Ifoly8UIfl!iiG|k%LKF;988or*x{!+K#KP+`T#wqM z!kr5t3Wlf@Pb%EGq#`=0aOaNbWTzC3)4VPt$azXp*w?~GXjD11XwE2Xe;+3K)WToj z9iggDEj;po=whIavmkk=7JJx80aEDH!ne9d$f9Y5?{Gngf;JI?DRqcFq#&Zx3V%pP zsH)TJQuW}0QK}SAuS-=`r>oR6H7}0rWV4IL#l=oT{;ub{!%rAHg3m{Mcc6dNw{?bq zW6}Il#ZhL~=UVPn`~CdC_*|;ZawD;LcEJH)4df%`@-vI(MecH#bhzm2cxbU z$j_?ls)78hx~}y91%=0nBhx?*MyVRe7ZiKgkV-0|3krX+XQV2(u<#$+Awyd$fQT+E zcDK!95YdH&|Ij{CuS_l~e3=9x3fhTv5Ya`&N9`Oii0GoizvMGgKZh(Xd|HJN1#OrB z5nWvP4i1Ru;=)&xBlXtrlA^U=nt32ZL3`{#M3)qMej!p3T~h4(CGSlvx|bHd=pLCC z-Jor*fru_GcC&{PM09E4ONWtKbe~=LW-&ymU{p?v?z4+eMMu=4`|QFui%05Sk#p*H z)uJ1WcGaT$oZ@2^jF1=6a|++_9jR+Z&MkZc6+#q@#?hkt++z3W!&-EoTlfa*NG-aT z)g4ibZZJf(=w4RrZf7LOi|De#_tZyf(Y?Ix5?XYF(XLu_FR$BGi|*xx|MW0Yi|!S5 zUG=L47%tVKdqpuM>Z(Qein^{Wy3Z>-gcz9?-C#U)T6CXRKXh7jpI7*ARU@_NKEHm{ zwde-pQP-mT{Nf|gL$v5Vzwix)k@~pK1%+=GLx_UW-?iwzpy>IE_a-g6FDQJoc%<$# zxv*$iR0bgm+G-d?^upp3pLbC$x-TsFq>pxdkLYBV7LCh&4myIImli(3AE6QNvcg}e zf_Sn)TLyvTy{zz45+GVHE9_o?))5+*Ru=xYAH;Y9S_lMU-^#*&iUm{VJ#A0`(X>*7 zf_8BSI@y&)6(%{H=NA$jb11W~Xio<|T1*A#x-eL!`+I)-QnQP38pU`qAxt$~PMtsz=lwgVd7 zuPgYT(nsRGp!%|W|DqXrP)H_gO%R3G75>#)5QWzjdw(u{Z*4$yBOT#C{@xnd&`CZE zl0kIdSbWlkDllo;_lxO!YXh1LZs8gHYu{TV5ly6qr!+U*QtW2EmQ*y|5~K8hVxwEB zZt92-qM!`~AfmSxyMHE95xrFv)9gDSC#e>| zLKL*w7esVpv4>3+Afg*%yd2Qnu&MCXCWI&$c{Mj|Dn4aD_>qd}rs7Ms+8of_usH^J z2vN|c6%f(Q#m8)b2NB(@0p6Yf=7zhA)))SRFP{yhZCWzL6QCL6?)nMPjB$6dw_U?9 zpc&(ym>nT(0i%sHW86~=vDuMSMDK~&aX>T1eMReEy#s2-03)wvjQfiJ_K%T@=zYaM zf781sGsXjj{|Y~lW(+WzOf$v<#m8-cBNfpH3jf7|~D=jmLfLK9Zb|#MphL2DvTVQIg~!o;=W2B_MgX6uyuI(YmGZ zU+a$40P|?!$HpNZf6&Hm5c?jDu^UX8_q4_Z(e!AMj*YikM{0O`tnh6d2vN{B&Ok&T zD|WVS0wVgD1+UH4s804|(fFNLZ4^15EZD|ToIXm!`%^{pSs&hElAkL4?x<0!`P0!9 z5QTy^$bjU1y6}rnKni`j@C}zyvgn!UI}lC-t>$1#ZQEO}AfnF{{+8<~RrR@W8idop z5LL~e3#XBarsoQG8i=On!fB&K&lgRb%ONy@p-BVx^F`anS5ndRe9>bAH<)A@xHV>u zk`XV&q86e$pq-`$5q+WXcgH|PU$8}Ovo*Sty;wAU@9rN>&KHZ~lga&~<^Gq7<~Daf zO!7;GZ+?uH`(FeQ~d<=a`}Whp{WUzg3$Q z)R1J4F_?1t9W)?nUMc(zn$c>C*P_=!h=TScfQY_U>}I_VMD(@jbz?f&>qX;Dul5*n zzFzn~-Wb*EjnE3A6*R3NdEW@FAX?uDt-t7Ge=HjBxYl2g^N-P4e<7`JhgJx!plJok z`*vsr(fW31J*t!axoEuST8|>)1}Vy=aUt zZF^-bIk$(cW2NfYQh^j8rYf;r@dM!#_W<*_% zNp%6OE+C>aqAnn!GomiXcCwjeV~*G5SaQxReRJwq)n!(+HiU;j8+SnR&MN&a4iK%g zthHOMV^!oCrOy};qF{)sE@zbfv3F7tJ)`vPj$`%M&#p!F*n{Q<5)qwU`eP3wI=dEy z&MccYs2-bwV=zQD#-3U3X3+M*E2*M!Hw1VWF z9|nPFogW4rCu`3t{dx)rH-P2_Fs1tS6dXITx3{`E|VNvZVAkoFM7~T3tZ$E-81j)jx>VC8h6R9j_vn z)}rd3V2G+NOKVZpWvPiaTPJj~bIZngZqNzjJh$|{-Vwp|10uS%Ovk{Rt&=<1wPoW5H|S(?UK>5|WEpf_7zCjeG=o6$UKa*|XuU2BI#~u? z9|l2)f@TnyQr#dB(d)yYUv;vZ%Em2j(67jOQw*iQl0i3zK@eI&GYBN_&0!FT)|<_s zX6x6TY+c#d;97r8&UK}SbibC?+e*KN0zxZjT0!#OR_ul`Myk(l1TfvYZ4 z(#Db-2_qfxjpZkLx=dLc)n8TCc*?r7Z2TWDYrM+3Q)L}MNHji`bvMJ;kiC13JF0&S zXApRKv%h<+064Or3nFwp-7nrTGbG8Ai)fLG6{Gp?k`PX2i814D4R$hP0%qJ>Htu&b zCdiC?%i=R>;F*xjxUXz}BgqPRK4B|MOqK5|S@KA?81ehco&&l}S@)G+*TQ^IYa(Sm zST>&WvL>pm2i38^hO;N`#HP$cCGY0!-E%O9@4L4v{*Te44jXa!cTz3AvSW2p;){Oh z9YNaVp^|rVWP}jCf5D6~i52%vOm%uVno&rdV5^guIz3$SBe1DUb$Yn`s5PU~snf&O zj7c4(JyP=Xq-R%ugU$V9S1lhY`GGRh5r3rQ7fQDVFYIv90ZG`_n!@X?ZMCp=lhAl&XU;*XZRuO8_sKNnHBIHfob}rRMw=_sh*8y6rvmMBwb>%KdV_;ri#)1 zteWkg==+n@_g^TRyA1ha>ic7k;>8n=BXJIQC_l#X#^E9TWBL7+Te5g5d-UP@fi`Wl z`-_0c^9a09a$kk1PmjP~Fug3XTZ=VYcd%A{7VcWB%5B}jT8)xht&7JZC@k;0xq8m2dVzR#yy2a>zB|0!n@~hE-g|s=GrJ9LTdTt$9jQFdi zcVL)`Zc~UYM+gyzt;>iJ-&S(PMx-OYO;NVmcnUT9L)m!4Yc@q?{XqkiYBnX+?DeRb zkeb1!OHB6Hqh?}szpk3`W6t1qCwr@G{0Y_VYS3Wq_P$jPw$B>0HL?8BW7WYBiC{Vo zC!|V$^i>#0;@c_|n?#1`Af}MKZ+lz@LhtwtFCs6PVqjrP<>ES3{S>PHZrPYv+0=K6 z^u8NaKP6TDy%-mSR2{aei^=|;W>vXWOx53uaRDazea+^cto{af#Z}t-n$II0@%J^M z%khX~>2}4Jo~$tvwg*|ssM{XHiWqg^$wOaQ1; zu=v3a;*>tF;?g|Vt}zm}0iNvIyc<`2*hVce;^QiQ()QBnk>e{LVoBDR2wMjiBR;-j zA?@n*JN)=6MJUM^ls2K_eQi(HuPv}W`G{*woKSI|HqsHFQ1QyPTKQC3d2-b_#asDQ z`F(Q5tt~R`)YQsTDt;N1tdN?*<`^+$O{rLaMLObBDt;UcrmQIyzYeObsgyOfYMka} zO;uS_D<3ANrn070K5Yuo4cmh%Ci}F?r%f@sr&T^}!X!_x*ojrqLQI9tR59wNS00Or zQ~pnUp_?Cd(<^pkRddqmVKXW=!Cak&4cHn*$%xOW*cgd)#Aj3UU-dU zjn!~hT&2ycJn~dJ;`735GcavI)mZGN%~0kAm0t=lBbm0a;?ijqEu`A84t5%oePPAn zk6?5!tazP8rjeiIMHP!LPnOrQI( zxWG+2U743x?7XPjrzg`^L}wAA8@A3OCi{x$EMj!8u+EaiNj|Ug6%NUIs$hGn#Hc$j z1^{u&&w^ZD6r=9EDy?vmI-aWYD{ce!WR2T!SDl`+^DB>S5tnDquecvL@}utjDjkk% z4&J$wT~swLr{bDG^_%BKyr`^&+TfivfnHqsj0uqlrlaUe#Egq8zb^CNOgu)S zssN^w6GHM{q7!JQ7rIn~t>u*{m_m2*YS6e;L#yS**vl%vLT%@?;Q*%n6Y}bow96{L zscmODVr6B!<0NXv0MmB3ki09aG+hm9&7{Gvs2Xd%!Dq_eD`Ie&nHv1cXmBAd1Y3iP z$$n)txEL$1j0T5EzN+GieR*7nVX(E37evJ#M%`+gK$1FeO^g8~YodnjNf9HyrYda=5U2cU3>eg!h2yTN z8rQkwX36wxDt?BMsk4&fu8mPyh;G;%Cno!~F)EAEeXWhkgIZ^x`-ZANTT2PGmt<|2NNw$e8>(KY>gcXcks55Vl9Ca>t@^MPWe4x^9T>sO+fQQ1PZr1Ubz_(QHm3imqermj>p%SPqlO)>1tAGz`p1rq42O;2>g77QYm%Zv z%CIK}6BHe8j3-8nNgHFi8{EePG>ytthiYt z(ouJ3#evpf)ZJNew!@o~qda$2&96jqg*v#aPG@`Ws@mP&pu;_PReSB*&5ydfs{Ov4 zp3*aUO7E!}zwxK^Og$I(RK7iMCXX50YSEE}=!UH$i^+a(bYwBQ@6|A^-9VV+`^nDU z*g*nNv5FV4)Q{#S(;g4g zgqQ}KX=1WJ9;S)W{dkxLll(-CDnhy;Y+e+j?umHj#3{eWTw>Hcp;6_BW(^Jalp63` zf29G3k2ridNBQ^Vj&lCj?LGgQ_M{}WC#tPI#aQxGw5J$Lo{H503_e}?&ZZD?*urEn z;!jt(ZHb9f{tt)Ht3I}Rt$+i&K90xfpdXgwJ7ozV*Mr=hBSRP;EXJW69R=xfn~f#xpb@ zr@dS?e(z43FSB2cuw;I6+A9(A2&pA(P7{;;l?Zvn=zb*@qA4?7?K8JDAwg?4;h{NV{G2+`Q-*y)xzAZul7Q`)xwxJa4DwSE3vL|JTtwS5yrh-t97K}`1XZQleD zqkDXt`SU|G@S>e`E^b1*Ii)=)wUPdSz=XDM?IHk9Z1Z}Enox-Cu(?8<(mk{gqkm#M zZ5K$t`u3!D%c5W*=D}TcQa`Ef4_pVVf|R{w*+$!!khdg&S|;cn^b+mqYvZf(`K zC%1jmdNH1x+HRcYo?9$ar?&mh=Ecc#)7o61D&0a%gH4y1?9)zF}i29(;nVnbgSqy z!ZabK!B$goO7~z@jQANcZD)4(cj;tv+Ku^Grp*bRs-DyKE8KTc-<{iTrsEKUAris# zv%3(F%x&BK;2??f+J4nKWN3R8AbIDtd5=Q_$5Onppxrpzy|Gkz7qoqUb!qa(!f0n9 z-hj;;VzMu6dmJdHIt$yrwFi^DXa{jU5O7yqr7hY)T;5o;gE*EhZZ~ZY9BrD$;I6pT zFK+uUcS=Wmaoc~ngTWtJgOF>SLXdYu?`OWJ$bwuCsz`?ds(_|mrjC@Mr8 zwjV{sh%asXkD_A4m$uVyN`qQwAwXlYLp+ zgI+PZmxZHXl9#J<=>+VVCR8bmtc%hg@f1amy63ZxGS#GF4W@}>4;z0PBZRc z6-O7iD4Z@t9PWxs{YCPli>u8qGN&hT@Zxs!vyrSW09zM8ow~rq(FMe)ySU9|r>;(2 z;NmvNm*uE)anxn)#+B}#vnB>db{)>(f zakwk4(k|DNDbtjW_~mW?MF+-FtD>etY6@FT#ng0F)KrYRRZ&wh>Q-4z2TMJ8MT}!Y ztbr};79)N|o3rI^jU07F46(~_)arKQT6feknZ7!P*k#F4Yoew?OoMGjCno!vHuu0t zw;0`PqNXs(Yj+UW5DRz3RodDe#O0{9JBZ_`tD{4rO+5;>K}C%C)ot!b@zUjqtD{4b z4qmfE>2eI*6_;bKX>)aji_0+nB_9{`gUP^3CojXZfN_@4MJ)L y+bk<4`wi{gY->V{?i(V0fJweFo)sbDusKGY(*MSu6*1yB@~j+^rSC=U|9=7f<@3$} diff --git a/datafusion/proto/src/datafusion.rs b/datafusion/proto/src/datafusion.rs deleted file mode 100644 index f50754494d1d..000000000000 --- a/datafusion/proto/src/datafusion.rs +++ /dev/null @@ -1,2917 +0,0 @@ -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ColumnRelation { - #[prost(string, tag = "1")] - pub relation: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Column { - #[prost(string, tag = "1")] - pub name: ::prost::alloc::string::String, - #[prost(message, optional, tag = "2")] - pub relation: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DfField { - #[prost(message, optional, tag = "1")] - pub field: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub qualifier: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DfSchema { - #[prost(message, repeated, tag = "1")] - pub columns: ::prost::alloc::vec::Vec, - #[prost(map = "string, string", tag = "2")] - pub metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, -} -/// logical plan -/// LogicalPlan is a nested type -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LogicalPlanNode { - #[prost( - oneof = "logical_plan_node::LogicalPlanType", - tags = "1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27" - )] - pub logical_plan_type: ::core::option::Option, -} -/// Nested message and enum types in `LogicalPlanNode`. -pub mod logical_plan_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum LogicalPlanType { - #[prost(message, tag = "1")] - ListingScan(super::ListingTableScanNode), - #[prost(message, tag = "3")] - Projection(::prost::alloc::boxed::Box), - #[prost(message, tag = "4")] - Selection(::prost::alloc::boxed::Box), - #[prost(message, tag = "5")] - Limit(::prost::alloc::boxed::Box), - #[prost(message, tag = "6")] - Aggregate(::prost::alloc::boxed::Box), - #[prost(message, tag = "7")] - Join(::prost::alloc::boxed::Box), - #[prost(message, tag = "8")] - Sort(::prost::alloc::boxed::Box), - #[prost(message, tag = "9")] - Repartition(::prost::alloc::boxed::Box), - #[prost(message, tag = "10")] - EmptyRelation(super::EmptyRelationNode), - #[prost(message, tag = "11")] - CreateExternalTable(super::CreateExternalTableNode), - #[prost(message, tag = "12")] - Explain(::prost::alloc::boxed::Box), - #[prost(message, tag = "13")] - Window(::prost::alloc::boxed::Box), - #[prost(message, tag = "14")] - Analyze(::prost::alloc::boxed::Box), - #[prost(message, tag = "15")] - CrossJoin(::prost::alloc::boxed::Box), - #[prost(message, tag = "16")] - Values(super::ValuesNode), - #[prost(message, tag = "17")] - Extension(super::LogicalExtensionNode), - #[prost(message, tag = "18")] - CreateCatalogSchema(super::CreateCatalogSchemaNode), - #[prost(message, tag = "19")] - Union(super::UnionNode), - #[prost(message, tag = "20")] - CreateCatalog(super::CreateCatalogNode), - #[prost(message, tag = "21")] - SubqueryAlias(::prost::alloc::boxed::Box), - #[prost(message, tag = "22")] - CreateView(::prost::alloc::boxed::Box), - #[prost(message, tag = "23")] - Distinct(::prost::alloc::boxed::Box), - #[prost(message, tag = "24")] - ViewScan(::prost::alloc::boxed::Box), - #[prost(message, tag = "25")] - CustomScan(super::CustomTableScanNode), - #[prost(message, tag = "26")] - Prepare(::prost::alloc::boxed::Box), - #[prost(message, tag = "27")] - DropView(super::DropViewNode), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LogicalExtensionNode { - #[prost(bytes = "vec", tag = "1")] - pub node: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "2")] - pub inputs: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ProjectionColumns { - #[prost(string, repeated, tag = "1")] - pub columns: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CsvFormat { - #[prost(bool, tag = "1")] - pub has_header: bool, - #[prost(string, tag = "2")] - pub delimiter: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ParquetFormat {} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AvroFormat {} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LogicalExprNodeCollection { - #[prost(message, repeated, tag = "1")] - pub logical_expr_nodes: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ListingTableScanNode { - #[prost(message, optional, tag = "14")] - pub table_name: ::core::option::Option, - #[prost(string, repeated, tag = "2")] - pub paths: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - #[prost(string, tag = "3")] - pub file_extension: ::prost::alloc::string::String, - #[prost(message, optional, tag = "4")] - pub projection: ::core::option::Option, - #[prost(message, optional, tag = "5")] - pub schema: ::core::option::Option, - #[prost(message, repeated, tag = "6")] - pub filters: ::prost::alloc::vec::Vec, - #[prost(string, repeated, tag = "7")] - pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - #[prost(bool, tag = "8")] - pub collect_stat: bool, - #[prost(uint32, tag = "9")] - pub target_partitions: u32, - #[prost(message, repeated, tag = "13")] - pub file_sort_order: ::prost::alloc::vec::Vec, - #[prost(oneof = "listing_table_scan_node::FileFormatType", tags = "10, 11, 12")] - pub file_format_type: ::core::option::Option< - listing_table_scan_node::FileFormatType, - >, -} -/// Nested message and enum types in `ListingTableScanNode`. -pub mod listing_table_scan_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum FileFormatType { - #[prost(message, tag = "10")] - Csv(super::CsvFormat), - #[prost(message, tag = "11")] - Parquet(super::ParquetFormat), - #[prost(message, tag = "12")] - Avro(super::AvroFormat), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ViewTableScanNode { - #[prost(message, optional, tag = "6")] - pub table_name: ::core::option::Option, - #[prost(message, optional, boxed, tag = "2")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "3")] - pub schema: ::core::option::Option, - #[prost(message, optional, tag = "4")] - pub projection: ::core::option::Option, - #[prost(string, tag = "5")] - pub definition: ::prost::alloc::string::String, -} -/// Logical Plan to Scan a CustomTableProvider registered at runtime -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CustomTableScanNode { - #[prost(message, optional, tag = "6")] - pub table_name: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub projection: ::core::option::Option, - #[prost(message, optional, tag = "3")] - pub schema: ::core::option::Option, - #[prost(message, repeated, tag = "4")] - pub filters: ::prost::alloc::vec::Vec, - #[prost(bytes = "vec", tag = "5")] - pub custom_table_data: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ProjectionNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub expr: ::prost::alloc::vec::Vec, - #[prost(oneof = "projection_node::OptionalAlias", tags = "3")] - pub optional_alias: ::core::option::Option, -} -/// Nested message and enum types in `ProjectionNode`. -pub mod projection_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum OptionalAlias { - #[prost(string, tag = "3")] - Alias(::prost::alloc::string::String), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SelectionNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub expr: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SortNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub expr: ::prost::alloc::vec::Vec, - /// Maximum number of highest/lowest rows to fetch; negative means no limit - #[prost(int64, tag = "3")] - pub fetch: i64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct RepartitionNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(oneof = "repartition_node::PartitionMethod", tags = "2, 3")] - pub partition_method: ::core::option::Option, -} -/// Nested message and enum types in `RepartitionNode`. -pub mod repartition_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum PartitionMethod { - #[prost(uint64, tag = "2")] - RoundRobin(u64), - #[prost(message, tag = "3")] - Hash(super::HashRepartition), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct HashRepartition { - #[prost(message, repeated, tag = "1")] - pub hash_expr: ::prost::alloc::vec::Vec, - #[prost(uint64, tag = "2")] - pub partition_count: u64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EmptyRelationNode { - #[prost(bool, tag = "1")] - pub produce_one_row: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CreateExternalTableNode { - #[prost(message, optional, tag = "12")] - pub name: ::core::option::Option, - #[prost(string, tag = "2")] - pub location: ::prost::alloc::string::String, - #[prost(string, tag = "3")] - pub file_type: ::prost::alloc::string::String, - #[prost(bool, tag = "4")] - pub has_header: bool, - #[prost(message, optional, tag = "5")] - pub schema: ::core::option::Option, - #[prost(string, repeated, tag = "6")] - pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - #[prost(bool, tag = "7")] - pub if_not_exists: bool, - #[prost(string, tag = "8")] - pub delimiter: ::prost::alloc::string::String, - #[prost(string, tag = "9")] - pub definition: ::prost::alloc::string::String, - #[prost(string, tag = "10")] - pub file_compression_type: ::prost::alloc::string::String, - #[prost(message, repeated, tag = "13")] - pub order_exprs: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "14")] - pub unbounded: bool, - #[prost(map = "string, string", tag = "11")] - pub options: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PrepareNode { - #[prost(string, tag = "1")] - pub name: ::prost::alloc::string::String, - #[prost(message, repeated, tag = "2")] - pub data_types: ::prost::alloc::vec::Vec, - #[prost(message, optional, boxed, tag = "3")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CreateCatalogSchemaNode { - #[prost(string, tag = "1")] - pub schema_name: ::prost::alloc::string::String, - #[prost(bool, tag = "2")] - pub if_not_exists: bool, - #[prost(message, optional, tag = "3")] - pub schema: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CreateCatalogNode { - #[prost(string, tag = "1")] - pub catalog_name: ::prost::alloc::string::String, - #[prost(bool, tag = "2")] - pub if_not_exists: bool, - #[prost(message, optional, tag = "3")] - pub schema: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DropViewNode { - #[prost(message, optional, tag = "1")] - pub name: ::core::option::Option, - #[prost(bool, tag = "2")] - pub if_exists: bool, - #[prost(message, optional, tag = "3")] - pub schema: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CreateViewNode { - #[prost(message, optional, tag = "5")] - pub name: ::core::option::Option, - #[prost(message, optional, boxed, tag = "2")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "3")] - pub or_replace: bool, - #[prost(string, tag = "4")] - pub definition: ::prost::alloc::string::String, -} -/// a node containing data for defining values list. unlike in SQL where it's two dimensional, here -/// the list is flattened, and with the field n_cols it can be parsed and partitioned into rows -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ValuesNode { - #[prost(uint64, tag = "1")] - pub n_cols: u64, - #[prost(message, repeated, tag = "2")] - pub values_list: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AnalyzeNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "2")] - pub verbose: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ExplainNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "2")] - pub verbose: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AggregateNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub group_expr: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "3")] - pub aggr_expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct WindowNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub window_expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct JoinNode { - #[prost(message, optional, boxed, tag = "1")] - pub left: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub right: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(enumeration = "JoinType", tag = "3")] - pub join_type: i32, - #[prost(enumeration = "JoinConstraint", tag = "4")] - pub join_constraint: i32, - #[prost(message, repeated, tag = "5")] - pub left_join_key: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "6")] - pub right_join_key: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "7")] - pub null_equals_null: bool, - #[prost(message, optional, tag = "8")] - pub filter: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct DistinctNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct UnionNode { - #[prost(message, repeated, tag = "1")] - pub inputs: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CrossJoinNode { - #[prost(message, optional, boxed, tag = "1")] - pub left: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub right: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LimitNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - /// The number of rows to skip before fetch; non-positive means don't skip any - #[prost(int64, tag = "2")] - pub skip: i64, - /// Maximum number of rows to fetch; negative means no limit - #[prost(int64, tag = "3")] - pub fetch: i64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SelectionExecNode { - #[prost(message, optional, tag = "1")] - pub expr: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SubqueryAliasNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "3")] - pub alias: ::core::option::Option, -} -/// logical expressions -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LogicalExprNode { - #[prost( - oneof = "logical_expr_node::ExprType", - tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34" - )] - pub expr_type: ::core::option::Option, -} -/// Nested message and enum types in `LogicalExprNode`. -pub mod logical_expr_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum ExprType { - /// column references - #[prost(message, tag = "1")] - Column(super::Column), - /// alias - #[prost(message, tag = "2")] - Alias(::prost::alloc::boxed::Box), - #[prost(message, tag = "3")] - Literal(super::ScalarValue), - /// binary expressions - #[prost(message, tag = "4")] - BinaryExpr(super::BinaryExprNode), - /// aggregate expressions - #[prost(message, tag = "5")] - AggregateExpr(::prost::alloc::boxed::Box), - /// null checks - #[prost(message, tag = "6")] - IsNullExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "7")] - IsNotNullExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "8")] - NotExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "9")] - Between(::prost::alloc::boxed::Box), - #[prost(message, tag = "10")] - Case(::prost::alloc::boxed::Box), - #[prost(message, tag = "11")] - Cast(::prost::alloc::boxed::Box), - #[prost(message, tag = "12")] - Sort(::prost::alloc::boxed::Box), - #[prost(message, tag = "13")] - Negative(::prost::alloc::boxed::Box), - #[prost(message, tag = "14")] - InList(::prost::alloc::boxed::Box), - #[prost(bool, tag = "15")] - Wildcard(bool), - #[prost(message, tag = "16")] - ScalarFunction(super::ScalarFunctionNode), - #[prost(message, tag = "17")] - TryCast(::prost::alloc::boxed::Box), - /// window expressions - #[prost(message, tag = "18")] - WindowExpr(::prost::alloc::boxed::Box), - /// AggregateUDF expressions - #[prost(message, tag = "19")] - AggregateUdfExpr(::prost::alloc::boxed::Box), - /// Scalar UDF expressions - #[prost(message, tag = "20")] - ScalarUdfExpr(super::ScalarUdfExprNode), - #[prost(message, tag = "21")] - GetIndexedField(::prost::alloc::boxed::Box), - #[prost(message, tag = "22")] - GroupingSet(super::GroupingSetNode), - #[prost(message, tag = "23")] - Cube(super::CubeNode), - #[prost(message, tag = "24")] - Rollup(super::RollupNode), - #[prost(message, tag = "25")] - IsTrue(::prost::alloc::boxed::Box), - #[prost(message, tag = "26")] - IsFalse(::prost::alloc::boxed::Box), - #[prost(message, tag = "27")] - IsUnknown(::prost::alloc::boxed::Box), - #[prost(message, tag = "28")] - IsNotTrue(::prost::alloc::boxed::Box), - #[prost(message, tag = "29")] - IsNotFalse(::prost::alloc::boxed::Box), - #[prost(message, tag = "30")] - IsNotUnknown(::prost::alloc::boxed::Box), - #[prost(message, tag = "31")] - Like(::prost::alloc::boxed::Box), - #[prost(message, tag = "32")] - Ilike(::prost::alloc::boxed::Box), - #[prost(message, tag = "33")] - SimilarTo(::prost::alloc::boxed::Box), - #[prost(message, tag = "34")] - Placeholder(super::PlaceholderNode), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PlaceholderNode { - #[prost(string, tag = "1")] - pub id: ::prost::alloc::string::String, - #[prost(message, optional, tag = "2")] - pub data_type: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LogicalExprList { - #[prost(message, repeated, tag = "1")] - pub expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GroupingSetNode { - #[prost(message, repeated, tag = "1")] - pub expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CubeNode { - #[prost(message, repeated, tag = "1")] - pub expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct RollupNode { - #[prost(message, repeated, tag = "1")] - pub expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GetIndexedField { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub key: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsNull { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsNotNull { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsTrue { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsFalse { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsUnknown { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsNotTrue { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsNotFalse { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IsNotUnknown { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Not { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AliasNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(string, tag = "2")] - pub alias: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct BinaryExprNode { - /// Represents the operands from the left inner most expression - /// to the right outer most expression where each of them are chained - /// with the operator 'op'. - #[prost(message, repeated, tag = "1")] - pub operands: ::prost::alloc::vec::Vec, - #[prost(string, tag = "3")] - pub op: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct NegativeNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct InListNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub list: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "3")] - pub negated: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarFunctionNode { - #[prost(enumeration = "ScalarFunction", tag = "1")] - pub fun: i32, - #[prost(message, repeated, tag = "2")] - pub args: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AggregateExprNode { - #[prost(enumeration = "AggregateFunction", tag = "1")] - pub aggr_function: i32, - #[prost(message, repeated, tag = "2")] - pub expr: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "3")] - pub distinct: bool, - #[prost(message, optional, boxed, tag = "4")] - pub filter: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "5")] - pub order_by: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AggregateUdfExprNode { - #[prost(string, tag = "1")] - pub fun_name: ::prost::alloc::string::String, - #[prost(message, repeated, tag = "2")] - pub args: ::prost::alloc::vec::Vec, - #[prost(message, optional, boxed, tag = "3")] - pub filter: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "4")] - pub order_by: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarUdfExprNode { - #[prost(string, tag = "1")] - pub fun_name: ::prost::alloc::string::String, - #[prost(message, repeated, tag = "2")] - pub args: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct WindowExprNode { - #[prost(message, optional, boxed, tag = "4")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "5")] - pub partition_by: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "6")] - pub order_by: ::prost::alloc::vec::Vec, - /// repeated LogicalExprNode filter = 7; - #[prost(message, optional, tag = "8")] - pub window_frame: ::core::option::Option, - #[prost(oneof = "window_expr_node::WindowFunction", tags = "1, 2, 3, 9")] - pub window_function: ::core::option::Option, -} -/// Nested message and enum types in `WindowExprNode`. -pub mod window_expr_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum WindowFunction { - #[prost(enumeration = "super::AggregateFunction", tag = "1")] - AggrFunction(i32), - #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")] - BuiltInFunction(i32), - #[prost(string, tag = "3")] - Udaf(::prost::alloc::string::String), - #[prost(string, tag = "9")] - Udwf(::prost::alloc::string::String), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct BetweenNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "2")] - pub negated: bool, - #[prost(message, optional, boxed, tag = "3")] - pub low: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "4")] - pub high: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LikeNode { - #[prost(bool, tag = "1")] - pub negated: bool, - #[prost(message, optional, boxed, tag = "2")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "3")] - pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(string, tag = "4")] - pub escape_char: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ILikeNode { - #[prost(bool, tag = "1")] - pub negated: bool, - #[prost(message, optional, boxed, tag = "2")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "3")] - pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(string, tag = "4")] - pub escape_char: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SimilarToNode { - #[prost(bool, tag = "1")] - pub negated: bool, - #[prost(message, optional, boxed, tag = "2")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "3")] - pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(string, tag = "4")] - pub escape_char: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CaseNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub when_then_expr: ::prost::alloc::vec::Vec, - #[prost(message, optional, boxed, tag = "3")] - pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct WhenThen { - #[prost(message, optional, tag = "1")] - pub when_expr: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub then_expr: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CastNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub arrow_type: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct TryCastNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub arrow_type: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SortExprNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "2")] - pub asc: bool, - #[prost(bool, tag = "3")] - pub nulls_first: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct WindowFrame { - #[prost(enumeration = "WindowFrameUnits", tag = "1")] - pub window_frame_units: i32, - #[prost(message, optional, tag = "2")] - pub start_bound: ::core::option::Option, - /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) - /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) - #[prost(oneof = "window_frame::EndBound", tags = "3")] - pub end_bound: ::core::option::Option, -} -/// Nested message and enum types in `WindowFrame`. -pub mod window_frame { - /// "optional" keyword is stable in protoc 3.15 but prost is still on 3.14 (see and ) - /// this syntax is ugly but is binary compatible with the "optional" keyword (see ) - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum EndBound { - #[prost(message, tag = "3")] - Bound(super::WindowFrameBound), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct WindowFrameBound { - #[prost(enumeration = "WindowFrameBoundType", tag = "1")] - pub window_frame_bound_type: i32, - #[prost(message, optional, tag = "2")] - pub bound_value: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Schema { - #[prost(message, repeated, tag = "1")] - pub columns: ::prost::alloc::vec::Vec, - #[prost(map = "string, string", tag = "2")] - pub metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Field { - /// name of the field - #[prost(string, tag = "1")] - pub name: ::prost::alloc::string::String, - #[prost(message, optional, boxed, tag = "2")] - pub arrow_type: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "3")] - pub nullable: bool, - /// for complex data types like structs, unions - #[prost(message, repeated, tag = "4")] - pub children: ::prost::alloc::vec::Vec, - #[prost(map = "string, string", tag = "5")] - pub metadata: ::std::collections::HashMap< - ::prost::alloc::string::String, - ::prost::alloc::string::String, - >, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct FixedSizeBinary { - #[prost(int32, tag = "1")] - pub length: i32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Timestamp { - #[prost(enumeration = "TimeUnit", tag = "1")] - pub time_unit: i32, - #[prost(string, tag = "2")] - pub timezone: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Decimal { - #[prost(uint32, tag = "3")] - pub precision: u32, - #[prost(int32, tag = "4")] - pub scale: i32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct List { - #[prost(message, optional, boxed, tag = "1")] - pub field_type: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct FixedSizeList { - #[prost(message, optional, boxed, tag = "1")] - pub field_type: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(int32, tag = "2")] - pub list_size: i32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Dictionary { - #[prost(message, optional, boxed, tag = "1")] - pub key: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub value: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Struct { - #[prost(message, repeated, tag = "1")] - pub sub_field_types: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Map { - #[prost(message, optional, boxed, tag = "1")] - pub field_type: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "2")] - pub keys_sorted: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Union { - #[prost(message, repeated, tag = "1")] - pub union_types: ::prost::alloc::vec::Vec, - #[prost(enumeration = "UnionMode", tag = "2")] - pub union_mode: i32, - #[prost(int32, repeated, tag = "3")] - pub type_ids: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarListValue { - /// encode null explicitly to distinguish a list with a null value - /// from a list with no values) - #[prost(bool, tag = "3")] - pub is_null: bool, - #[prost(message, optional, tag = "1")] - pub field: ::core::option::Option, - #[prost(message, repeated, tag = "2")] - pub values: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarTime32Value { - #[prost(oneof = "scalar_time32_value::Value", tags = "1, 2")] - pub value: ::core::option::Option, -} -/// Nested message and enum types in `ScalarTime32Value`. -pub mod scalar_time32_value { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Value { - #[prost(int32, tag = "1")] - Time32SecondValue(i32), - #[prost(int32, tag = "2")] - Time32MillisecondValue(i32), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarTime64Value { - #[prost(oneof = "scalar_time64_value::Value", tags = "1, 2")] - pub value: ::core::option::Option, -} -/// Nested message and enum types in `ScalarTime64Value`. -pub mod scalar_time64_value { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Value { - #[prost(int64, tag = "1")] - Time64MicrosecondValue(i64), - #[prost(int64, tag = "2")] - Time64NanosecondValue(i64), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarTimestampValue { - #[prost(string, tag = "5")] - pub timezone: ::prost::alloc::string::String, - #[prost(oneof = "scalar_timestamp_value::Value", tags = "1, 2, 3, 4")] - pub value: ::core::option::Option, -} -/// Nested message and enum types in `ScalarTimestampValue`. -pub mod scalar_timestamp_value { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Value { - #[prost(int64, tag = "1")] - TimeMicrosecondValue(i64), - #[prost(int64, tag = "2")] - TimeNanosecondValue(i64), - #[prost(int64, tag = "3")] - TimeSecondValue(i64), - #[prost(int64, tag = "4")] - TimeMillisecondValue(i64), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarDictionaryValue { - #[prost(message, optional, tag = "1")] - pub index_type: ::core::option::Option, - #[prost(message, optional, boxed, tag = "2")] - pub value: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct IntervalMonthDayNanoValue { - #[prost(int32, tag = "1")] - pub months: i32, - #[prost(int32, tag = "2")] - pub days: i32, - #[prost(int64, tag = "3")] - pub nanos: i64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct StructValue { - /// Note that a null struct value must have one or more fields, so we - /// encode a null StructValue as one witth an empty field_values - /// list. - #[prost(message, repeated, tag = "2")] - pub field_values: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "3")] - pub fields: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarFixedSizeBinary { - #[prost(bytes = "vec", tag = "1")] - pub values: ::prost::alloc::vec::Vec, - #[prost(int32, tag = "2")] - pub length: i32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScalarValue { - #[prost( - oneof = "scalar_value::Value", - tags = "33, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 20, 21, 24, 25, 35, 36, 37, 38, 26, 27, 28, 29, 30, 31, 32, 34" - )] - pub value: ::core::option::Option, -} -/// Nested message and enum types in `ScalarValue`. -pub mod scalar_value { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum Value { - /// was PrimitiveScalarType null_value = 19; - /// Null value of any type - #[prost(message, tag = "33")] - NullValue(super::ArrowType), - #[prost(bool, tag = "1")] - BoolValue(bool), - #[prost(string, tag = "2")] - Utf8Value(::prost::alloc::string::String), - #[prost(string, tag = "3")] - LargeUtf8Value(::prost::alloc::string::String), - #[prost(int32, tag = "4")] - Int8Value(i32), - #[prost(int32, tag = "5")] - Int16Value(i32), - #[prost(int32, tag = "6")] - Int32Value(i32), - #[prost(int64, tag = "7")] - Int64Value(i64), - #[prost(uint32, tag = "8")] - Uint8Value(u32), - #[prost(uint32, tag = "9")] - Uint16Value(u32), - #[prost(uint32, tag = "10")] - Uint32Value(u32), - #[prost(uint64, tag = "11")] - Uint64Value(u64), - #[prost(float, tag = "12")] - Float32Value(f32), - #[prost(double, tag = "13")] - Float64Value(f64), - /// Literal Date32 value always has a unit of day - #[prost(int32, tag = "14")] - Date32Value(i32), - #[prost(message, tag = "15")] - Time32Value(super::ScalarTime32Value), - /// WAS: ScalarType null_list_value = 18; - #[prost(message, tag = "17")] - ListValue(super::ScalarListValue), - #[prost(message, tag = "20")] - Decimal128Value(super::Decimal128), - #[prost(int64, tag = "21")] - Date64Value(i64), - #[prost(int32, tag = "24")] - IntervalYearmonthValue(i32), - #[prost(int64, tag = "25")] - IntervalDaytimeValue(i64), - #[prost(int64, tag = "35")] - DurationSecondValue(i64), - #[prost(int64, tag = "36")] - DurationMillisecondValue(i64), - #[prost(int64, tag = "37")] - DurationMicrosecondValue(i64), - #[prost(int64, tag = "38")] - DurationNanosecondValue(i64), - #[prost(message, tag = "26")] - TimestampValue(super::ScalarTimestampValue), - #[prost(message, tag = "27")] - DictionaryValue(::prost::alloc::boxed::Box), - #[prost(bytes, tag = "28")] - BinaryValue(::prost::alloc::vec::Vec), - #[prost(bytes, tag = "29")] - LargeBinaryValue(::prost::alloc::vec::Vec), - #[prost(message, tag = "30")] - Time64Value(super::ScalarTime64Value), - #[prost(message, tag = "31")] - IntervalMonthDayNano(super::IntervalMonthDayNanoValue), - #[prost(message, tag = "32")] - StructValue(super::StructValue), - #[prost(message, tag = "34")] - FixedSizeBinaryValue(super::ScalarFixedSizeBinary), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Decimal128 { - #[prost(bytes = "vec", tag = "1")] - pub value: ::prost::alloc::vec::Vec, - #[prost(int64, tag = "2")] - pub p: i64, - #[prost(int64, tag = "3")] - pub s: i64, -} -/// Serialized data type -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ArrowType { - #[prost( - oneof = "arrow_type::ArrowTypeEnum", - tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 32, 15, 16, 31, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 33" - )] - pub arrow_type_enum: ::core::option::Option, -} -/// Nested message and enum types in `ArrowType`. -pub mod arrow_type { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum ArrowTypeEnum { - /// arrow::Type::NA - #[prost(message, tag = "1")] - None(super::EmptyMessage), - /// arrow::Type::BOOL - #[prost(message, tag = "2")] - Bool(super::EmptyMessage), - /// arrow::Type::UINT8 - #[prost(message, tag = "3")] - Uint8(super::EmptyMessage), - /// arrow::Type::INT8 - #[prost(message, tag = "4")] - Int8(super::EmptyMessage), - /// represents arrow::Type fields in src/arrow/type.h - #[prost(message, tag = "5")] - Uint16(super::EmptyMessage), - #[prost(message, tag = "6")] - Int16(super::EmptyMessage), - #[prost(message, tag = "7")] - Uint32(super::EmptyMessage), - #[prost(message, tag = "8")] - Int32(super::EmptyMessage), - #[prost(message, tag = "9")] - Uint64(super::EmptyMessage), - #[prost(message, tag = "10")] - Int64(super::EmptyMessage), - #[prost(message, tag = "11")] - Float16(super::EmptyMessage), - #[prost(message, tag = "12")] - Float32(super::EmptyMessage), - #[prost(message, tag = "13")] - Float64(super::EmptyMessage), - #[prost(message, tag = "14")] - Utf8(super::EmptyMessage), - #[prost(message, tag = "32")] - LargeUtf8(super::EmptyMessage), - #[prost(message, tag = "15")] - Binary(super::EmptyMessage), - #[prost(int32, tag = "16")] - FixedSizeBinary(i32), - #[prost(message, tag = "31")] - LargeBinary(super::EmptyMessage), - #[prost(message, tag = "17")] - Date32(super::EmptyMessage), - #[prost(message, tag = "18")] - Date64(super::EmptyMessage), - #[prost(enumeration = "super::TimeUnit", tag = "19")] - Duration(i32), - #[prost(message, tag = "20")] - Timestamp(super::Timestamp), - #[prost(enumeration = "super::TimeUnit", tag = "21")] - Time32(i32), - #[prost(enumeration = "super::TimeUnit", tag = "22")] - Time64(i32), - #[prost(enumeration = "super::IntervalUnit", tag = "23")] - Interval(i32), - #[prost(message, tag = "24")] - Decimal(super::Decimal), - #[prost(message, tag = "25")] - List(::prost::alloc::boxed::Box), - #[prost(message, tag = "26")] - LargeList(::prost::alloc::boxed::Box), - #[prost(message, tag = "27")] - FixedSizeList(::prost::alloc::boxed::Box), - #[prost(message, tag = "28")] - Struct(super::Struct), - #[prost(message, tag = "29")] - Union(super::Union), - #[prost(message, tag = "30")] - Dictionary(::prost::alloc::boxed::Box), - #[prost(message, tag = "33")] - Map(::prost::alloc::boxed::Box), - } -} -/// Useful for representing an empty enum variant in rust -/// E.G. enum example{One, Two(i32)} -/// maps to -/// message example{ -/// oneof{ -/// EmptyMessage One = 1; -/// i32 Two = 2; -/// } -/// } -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EmptyMessage {} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AnalyzedLogicalPlanType { - #[prost(string, tag = "1")] - pub analyzer_name: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct OptimizedLogicalPlanType { - #[prost(string, tag = "1")] - pub optimizer_name: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct OptimizedPhysicalPlanType { - #[prost(string, tag = "1")] - pub optimizer_name: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PlanType { - #[prost(oneof = "plan_type::PlanTypeEnum", tags = "1, 7, 8, 2, 3, 4, 5, 6")] - pub plan_type_enum: ::core::option::Option, -} -/// Nested message and enum types in `PlanType`. -pub mod plan_type { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum PlanTypeEnum { - #[prost(message, tag = "1")] - InitialLogicalPlan(super::EmptyMessage), - #[prost(message, tag = "7")] - AnalyzedLogicalPlan(super::AnalyzedLogicalPlanType), - #[prost(message, tag = "8")] - FinalAnalyzedLogicalPlan(super::EmptyMessage), - #[prost(message, tag = "2")] - OptimizedLogicalPlan(super::OptimizedLogicalPlanType), - #[prost(message, tag = "3")] - FinalLogicalPlan(super::EmptyMessage), - #[prost(message, tag = "4")] - InitialPhysicalPlan(super::EmptyMessage), - #[prost(message, tag = "5")] - OptimizedPhysicalPlan(super::OptimizedPhysicalPlanType), - #[prost(message, tag = "6")] - FinalPhysicalPlan(super::EmptyMessage), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct StringifiedPlan { - #[prost(message, optional, tag = "1")] - pub plan_type: ::core::option::Option, - #[prost(string, tag = "2")] - pub plan: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct BareTableReference { - #[prost(string, tag = "1")] - pub table: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PartialTableReference { - #[prost(string, tag = "1")] - pub schema: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub table: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct FullTableReference { - #[prost(string, tag = "1")] - pub catalog: ::prost::alloc::string::String, - #[prost(string, tag = "2")] - pub schema: ::prost::alloc::string::String, - #[prost(string, tag = "3")] - pub table: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct OwnedTableReference { - #[prost(oneof = "owned_table_reference::TableReferenceEnum", tags = "1, 2, 3")] - pub table_reference_enum: ::core::option::Option< - owned_table_reference::TableReferenceEnum, - >, -} -/// Nested message and enum types in `OwnedTableReference`. -pub mod owned_table_reference { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum TableReferenceEnum { - #[prost(message, tag = "1")] - Bare(super::BareTableReference), - #[prost(message, tag = "2")] - Partial(super::PartialTableReference), - #[prost(message, tag = "3")] - Full(super::FullTableReference), - } -} -/// PhysicalPlanNode is a nested type -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalPlanNode { - #[prost( - oneof = "physical_plan_node::PhysicalPlanType", - tags = "1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22" - )] - pub physical_plan_type: ::core::option::Option, -} -/// Nested message and enum types in `PhysicalPlanNode`. -pub mod physical_plan_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum PhysicalPlanType { - #[prost(message, tag = "1")] - ParquetScan(super::ParquetScanExecNode), - #[prost(message, tag = "2")] - CsvScan(super::CsvScanExecNode), - #[prost(message, tag = "3")] - Empty(super::EmptyExecNode), - #[prost(message, tag = "4")] - Projection(::prost::alloc::boxed::Box), - #[prost(message, tag = "6")] - GlobalLimit(::prost::alloc::boxed::Box), - #[prost(message, tag = "7")] - LocalLimit(::prost::alloc::boxed::Box), - #[prost(message, tag = "8")] - Aggregate(::prost::alloc::boxed::Box), - #[prost(message, tag = "9")] - HashJoin(::prost::alloc::boxed::Box), - #[prost(message, tag = "10")] - Sort(::prost::alloc::boxed::Box), - #[prost(message, tag = "11")] - CoalesceBatches(::prost::alloc::boxed::Box), - #[prost(message, tag = "12")] - Filter(::prost::alloc::boxed::Box), - #[prost(message, tag = "13")] - Merge(::prost::alloc::boxed::Box), - #[prost(message, tag = "14")] - Repartition(::prost::alloc::boxed::Box), - #[prost(message, tag = "15")] - Window(::prost::alloc::boxed::Box), - #[prost(message, tag = "16")] - CrossJoin(::prost::alloc::boxed::Box), - #[prost(message, tag = "17")] - AvroScan(super::AvroScanExecNode), - #[prost(message, tag = "18")] - Extension(super::PhysicalExtensionNode), - #[prost(message, tag = "19")] - Union(super::UnionExecNode), - #[prost(message, tag = "20")] - Explain(super::ExplainExecNode), - #[prost(message, tag = "21")] - SortPreservingMerge( - ::prost::alloc::boxed::Box, - ), - #[prost(message, tag = "22")] - NestedLoopJoin(::prost::alloc::boxed::Box), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalExtensionNode { - #[prost(bytes = "vec", tag = "1")] - pub node: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "2")] - pub inputs: ::prost::alloc::vec::Vec, -} -/// physical expressions -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalExprNode { - #[prost( - oneof = "physical_expr_node::ExprType", - tags = "1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19" - )] - pub expr_type: ::core::option::Option, -} -/// Nested message and enum types in `PhysicalExprNode`. -pub mod physical_expr_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum ExprType { - /// column references - #[prost(message, tag = "1")] - Column(super::PhysicalColumn), - #[prost(message, tag = "2")] - Literal(super::ScalarValue), - /// binary expressions - #[prost(message, tag = "3")] - BinaryExpr(::prost::alloc::boxed::Box), - /// aggregate expressions - #[prost(message, tag = "4")] - AggregateExpr(super::PhysicalAggregateExprNode), - /// null checks - #[prost(message, tag = "5")] - IsNullExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "6")] - IsNotNullExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "7")] - NotExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "8")] - Case(::prost::alloc::boxed::Box), - #[prost(message, tag = "9")] - Cast(::prost::alloc::boxed::Box), - #[prost(message, tag = "10")] - Sort(::prost::alloc::boxed::Box), - #[prost(message, tag = "11")] - Negative(::prost::alloc::boxed::Box), - #[prost(message, tag = "12")] - InList(::prost::alloc::boxed::Box), - #[prost(message, tag = "13")] - ScalarFunction(super::PhysicalScalarFunctionNode), - #[prost(message, tag = "14")] - TryCast(::prost::alloc::boxed::Box), - /// window expressions - #[prost(message, tag = "15")] - WindowExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "16")] - ScalarUdf(super::PhysicalScalarUdfNode), - #[prost(message, tag = "17")] - DateTimeIntervalExpr( - ::prost::alloc::boxed::Box, - ), - #[prost(message, tag = "18")] - LikeExpr(::prost::alloc::boxed::Box), - #[prost(message, tag = "19")] - GetIndexedFieldExpr( - ::prost::alloc::boxed::Box, - ), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalScalarUdfNode { - #[prost(string, tag = "1")] - pub name: ::prost::alloc::string::String, - #[prost(message, repeated, tag = "2")] - pub args: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "4")] - pub return_type: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalAggregateExprNode { - #[prost(message, repeated, tag = "2")] - pub expr: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "5")] - pub ordering_req: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "3")] - pub distinct: bool, - #[prost(oneof = "physical_aggregate_expr_node::AggregateFunction", tags = "1, 4")] - pub aggregate_function: ::core::option::Option< - physical_aggregate_expr_node::AggregateFunction, - >, -} -/// Nested message and enum types in `PhysicalAggregateExprNode`. -pub mod physical_aggregate_expr_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum AggregateFunction { - #[prost(enumeration = "super::AggregateFunction", tag = "1")] - AggrFunction(i32), - #[prost(string, tag = "4")] - UserDefinedAggrFunction(::prost::alloc::string::String), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalWindowExprNode { - #[prost(message, optional, boxed, tag = "4")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(oneof = "physical_window_expr_node::WindowFunction", tags = "1, 2")] - pub window_function: ::core::option::Option< - physical_window_expr_node::WindowFunction, - >, -} -/// Nested message and enum types in `PhysicalWindowExprNode`. -pub mod physical_window_expr_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum WindowFunction { - #[prost(enumeration = "super::AggregateFunction", tag = "1")] - AggrFunction(i32), - /// udaf = 3 - #[prost(enumeration = "super::BuiltInWindowFunction", tag = "2")] - BuiltInFunction(i32), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalIsNull { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalIsNotNull { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalNot { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalAliasNode { - #[prost(message, optional, tag = "1")] - pub expr: ::core::option::Option, - #[prost(string, tag = "2")] - pub alias: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalBinaryExprNode { - #[prost(message, optional, boxed, tag = "1")] - pub l: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub r: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(string, tag = "3")] - pub op: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalDateTimeIntervalExprNode { - #[prost(message, optional, boxed, tag = "1")] - pub l: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub r: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(string, tag = "3")] - pub op: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalLikeExprNode { - #[prost(bool, tag = "1")] - pub negated: bool, - #[prost(bool, tag = "2")] - pub case_insensitive: bool, - #[prost(message, optional, boxed, tag = "3")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "4")] - pub pattern: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalSortExprNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(bool, tag = "2")] - pub asc: bool, - #[prost(bool, tag = "3")] - pub nulls_first: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalWhenThen { - #[prost(message, optional, tag = "1")] - pub when_expr: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub then_expr: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalInListNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub list: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "3")] - pub negated: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalCaseNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub when_then_expr: ::prost::alloc::vec::Vec, - #[prost(message, optional, boxed, tag = "3")] - pub else_expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalScalarFunctionNode { - #[prost(string, tag = "1")] - pub name: ::prost::alloc::string::String, - #[prost(enumeration = "ScalarFunction", tag = "2")] - pub fun: i32, - #[prost(message, repeated, tag = "3")] - pub args: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "4")] - pub return_type: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalTryCastNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub arrow_type: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalCastNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub arrow_type: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalNegativeNode { - #[prost(message, optional, boxed, tag = "1")] - pub expr: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct FilterExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub expr: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct FileGroup { - #[prost(message, repeated, tag = "1")] - pub files: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ScanLimit { - /// wrap into a message to make it optional - #[prost(uint32, tag = "1")] - pub limit: u32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalSortExprNodeCollection { - #[prost(message, repeated, tag = "1")] - pub physical_sort_expr_nodes: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct FileScanExecConf { - #[prost(message, repeated, tag = "1")] - pub file_groups: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "2")] - pub schema: ::core::option::Option, - #[prost(uint32, repeated, tag = "4")] - pub projection: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "5")] - pub limit: ::core::option::Option, - #[prost(message, optional, tag = "6")] - pub statistics: ::core::option::Option, - #[prost(string, repeated, tag = "7")] - pub table_partition_cols: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - #[prost(string, tag = "8")] - pub object_store_url: ::prost::alloc::string::String, - #[prost(message, repeated, tag = "9")] - pub output_ordering: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ParquetScanExecNode { - #[prost(message, optional, tag = "1")] - pub base_conf: ::core::option::Option, - #[prost(message, optional, tag = "3")] - pub predicate: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CsvScanExecNode { - #[prost(message, optional, tag = "1")] - pub base_conf: ::core::option::Option, - #[prost(bool, tag = "2")] - pub has_header: bool, - #[prost(string, tag = "3")] - pub delimiter: ::prost::alloc::string::String, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AvroScanExecNode { - #[prost(message, optional, tag = "1")] - pub base_conf: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct HashJoinExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub left: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub right: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "3")] - pub on: ::prost::alloc::vec::Vec, - #[prost(enumeration = "JoinType", tag = "4")] - pub join_type: i32, - #[prost(enumeration = "PartitionMode", tag = "6")] - pub partition_mode: i32, - #[prost(bool, tag = "7")] - pub null_equals_null: bool, - #[prost(message, optional, tag = "8")] - pub filter: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct UnionExecNode { - #[prost(message, repeated, tag = "1")] - pub inputs: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ExplainExecNode { - #[prost(message, optional, tag = "1")] - pub schema: ::core::option::Option, - #[prost(message, repeated, tag = "2")] - pub stringified_plans: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "3")] - pub verbose: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CrossJoinExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub left: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub right: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalColumn { - #[prost(string, tag = "1")] - pub name: ::prost::alloc::string::String, - #[prost(uint32, tag = "2")] - pub index: u32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct JoinOn { - #[prost(message, optional, tag = "1")] - pub left: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub right: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct EmptyExecNode { - #[prost(bool, tag = "1")] - pub produce_one_row: bool, - #[prost(message, optional, tag = "2")] - pub schema: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ProjectionExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub expr: ::prost::alloc::vec::Vec, - #[prost(string, repeated, tag = "3")] - pub expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct WindowAggExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub window_expr: ::prost::alloc::vec::Vec, - #[prost(string, repeated, tag = "3")] - pub window_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - #[prost(message, optional, tag = "4")] - pub input_schema: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MaybeFilter { - #[prost(message, optional, tag = "1")] - pub expr: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct MaybePhysicalSortExprs { - #[prost(message, repeated, tag = "1")] - pub sort_expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct AggregateExecNode { - #[prost(message, repeated, tag = "1")] - pub group_expr: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "2")] - pub aggr_expr: ::prost::alloc::vec::Vec, - #[prost(enumeration = "AggregateMode", tag = "3")] - pub mode: i32, - #[prost(message, optional, boxed, tag = "4")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(string, repeated, tag = "5")] - pub group_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - #[prost(string, repeated, tag = "6")] - pub aggr_expr_name: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, - /// we need the input schema to the partial aggregate to pass to the final aggregate - #[prost(message, optional, tag = "7")] - pub input_schema: ::core::option::Option, - #[prost(message, repeated, tag = "8")] - pub null_expr: ::prost::alloc::vec::Vec, - #[prost(bool, repeated, tag = "9")] - pub groups: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "10")] - pub filter_expr: ::prost::alloc::vec::Vec, - #[prost(message, repeated, tag = "11")] - pub order_by_expr: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct GlobalLimitExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - /// The number of rows to skip before fetch - #[prost(uint32, tag = "2")] - pub skip: u32, - /// Maximum number of rows to fetch; negative means no limit - #[prost(int64, tag = "3")] - pub fetch: i64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct LocalLimitExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(uint32, tag = "2")] - pub fetch: u32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SortExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub expr: ::prost::alloc::vec::Vec, - /// Maximum number of highest/lowest rows to fetch; negative means no limit - #[prost(int64, tag = "3")] - pub fetch: i64, - #[prost(bool, tag = "4")] - pub preserve_partitioning: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct SortPreservingMergeExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, repeated, tag = "2")] - pub expr: ::prost::alloc::vec::Vec, - /// Maximum number of highest/lowest rows to fetch; negative means no limit - #[prost(int64, tag = "3")] - pub fetch: i64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct NestedLoopJoinExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub left: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, boxed, tag = "2")] - pub right: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(enumeration = "JoinType", tag = "3")] - pub join_type: i32, - #[prost(message, optional, tag = "4")] - pub filter: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CoalesceBatchesExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(uint32, tag = "2")] - pub target_batch_size: u32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct CoalescePartitionsExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalHashRepartition { - #[prost(message, repeated, tag = "1")] - pub hash_expr: ::prost::alloc::vec::Vec, - #[prost(uint64, tag = "2")] - pub partition_count: u64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct RepartitionExecNode { - #[prost(message, optional, boxed, tag = "1")] - pub input: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(oneof = "repartition_exec_node::PartitionMethod", tags = "2, 3, 4")] - pub partition_method: ::core::option::Option, -} -/// Nested message and enum types in `RepartitionExecNode`. -pub mod repartition_exec_node { - #[allow(clippy::derive_partial_eq_without_eq)] - #[derive(Clone, PartialEq, ::prost::Oneof)] - pub enum PartitionMethod { - #[prost(uint64, tag = "2")] - RoundRobin(u64), - #[prost(message, tag = "3")] - Hash(super::PhysicalHashRepartition), - #[prost(uint64, tag = "4")] - Unknown(u64), - } -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct JoinFilter { - #[prost(message, optional, tag = "1")] - pub expression: ::core::option::Option, - #[prost(message, repeated, tag = "2")] - pub column_indices: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "3")] - pub schema: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ColumnIndex { - #[prost(uint32, tag = "1")] - pub index: u32, - #[prost(enumeration = "JoinSide", tag = "2")] - pub side: i32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PartitionedFile { - #[prost(string, tag = "1")] - pub path: ::prost::alloc::string::String, - #[prost(uint64, tag = "2")] - pub size: u64, - #[prost(uint64, tag = "3")] - pub last_modified_ns: u64, - #[prost(message, repeated, tag = "4")] - pub partition_values: ::prost::alloc::vec::Vec, - #[prost(message, optional, tag = "5")] - pub range: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct FileRange { - #[prost(int64, tag = "1")] - pub start: i64, - #[prost(int64, tag = "2")] - pub end: i64, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PartitionStats { - #[prost(int64, tag = "1")] - pub num_rows: i64, - #[prost(int64, tag = "2")] - pub num_batches: i64, - #[prost(int64, tag = "3")] - pub num_bytes: i64, - #[prost(message, repeated, tag = "4")] - pub column_stats: ::prost::alloc::vec::Vec, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct Statistics { - #[prost(int64, tag = "1")] - pub num_rows: i64, - #[prost(int64, tag = "2")] - pub total_byte_size: i64, - #[prost(message, repeated, tag = "3")] - pub column_stats: ::prost::alloc::vec::Vec, - #[prost(bool, tag = "4")] - pub is_exact: bool, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct ColumnStats { - #[prost(message, optional, tag = "1")] - pub min_value: ::core::option::Option, - #[prost(message, optional, tag = "2")] - pub max_value: ::core::option::Option, - #[prost(uint32, tag = "3")] - pub null_count: u32, - #[prost(uint32, tag = "4")] - pub distinct_count: u32, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] -pub struct PhysicalGetIndexedFieldExprNode { - #[prost(message, optional, boxed, tag = "1")] - pub arg: ::core::option::Option<::prost::alloc::boxed::Box>, - #[prost(message, optional, tag = "2")] - pub key: ::core::option::Option, -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum JoinType { - Inner = 0, - Left = 1, - Right = 2, - Full = 3, - Leftsemi = 4, - Leftanti = 5, - Rightsemi = 6, - Rightanti = 7, -} -impl JoinType { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - JoinType::Inner => "INNER", - JoinType::Left => "LEFT", - JoinType::Right => "RIGHT", - JoinType::Full => "FULL", - JoinType::Leftsemi => "LEFTSEMI", - JoinType::Leftanti => "LEFTANTI", - JoinType::Rightsemi => "RIGHTSEMI", - JoinType::Rightanti => "RIGHTANTI", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "INNER" => Some(Self::Inner), - "LEFT" => Some(Self::Left), - "RIGHT" => Some(Self::Right), - "FULL" => Some(Self::Full), - "LEFTSEMI" => Some(Self::Leftsemi), - "LEFTANTI" => Some(Self::Leftanti), - "RIGHTSEMI" => Some(Self::Rightsemi), - "RIGHTANTI" => Some(Self::Rightanti), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum JoinConstraint { - On = 0, - Using = 1, -} -impl JoinConstraint { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - JoinConstraint::On => "ON", - JoinConstraint::Using => "USING", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "ON" => Some(Self::On), - "USING" => Some(Self::Using), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum ScalarFunction { - Abs = 0, - Acos = 1, - Asin = 2, - Atan = 3, - Ascii = 4, - Ceil = 5, - Cos = 6, - Digest = 7, - Exp = 8, - Floor = 9, - Ln = 10, - Log = 11, - Log10 = 12, - Log2 = 13, - Round = 14, - Signum = 15, - Sin = 16, - Sqrt = 17, - Tan = 18, - Trunc = 19, - Array = 20, - RegexpMatch = 21, - BitLength = 22, - Btrim = 23, - CharacterLength = 24, - Chr = 25, - Concat = 26, - ConcatWithSeparator = 27, - DatePart = 28, - DateTrunc = 29, - InitCap = 30, - Left = 31, - Lpad = 32, - Lower = 33, - Ltrim = 34, - Md5 = 35, - NullIf = 36, - OctetLength = 37, - Random = 38, - RegexpReplace = 39, - Repeat = 40, - Replace = 41, - Reverse = 42, - Right = 43, - Rpad = 44, - Rtrim = 45, - Sha224 = 46, - Sha256 = 47, - Sha384 = 48, - Sha512 = 49, - SplitPart = 50, - StartsWith = 51, - Strpos = 52, - Substr = 53, - ToHex = 54, - ToTimestamp = 55, - ToTimestampMillis = 56, - ToTimestampMicros = 57, - ToTimestampSeconds = 58, - Now = 59, - Translate = 60, - Trim = 61, - Upper = 62, - Coalesce = 63, - Power = 64, - StructFun = 65, - FromUnixtime = 66, - Atan2 = 67, - DateBin = 68, - ArrowTypeof = 69, - CurrentDate = 70, - CurrentTime = 71, - Uuid = 72, - Cbrt = 73, - Acosh = 74, - Asinh = 75, - Atanh = 76, - Sinh = 77, - Cosh = 78, - Tanh = 79, - Pi = 80, - Degrees = 81, - Radians = 82, - Factorial = 83, - Lcm = 84, - Gcd = 85, - ArrayAppend = 86, - ArrayConcat = 87, - ArrayDims = 88, - ArrayFill = 89, - ArrayLength = 90, - ArrayNdims = 91, - ArrayPosition = 92, - ArrayPositions = 93, - ArrayPrepend = 94, - ArrayRemove = 95, - ArrayReplace = 96, - ArrayToString = 97, - Cardinality = 98, - TrimArray = 99, - Encode = 101, - Decode = 102, - Cot = 103, - ArrayHas = 104, - ArrayHasAny = 105, - ArrayHasAll = 106, -} -impl ScalarFunction { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - ScalarFunction::Abs => "Abs", - ScalarFunction::Acos => "Acos", - ScalarFunction::Asin => "Asin", - ScalarFunction::Atan => "Atan", - ScalarFunction::Ascii => "Ascii", - ScalarFunction::Ceil => "Ceil", - ScalarFunction::Cos => "Cos", - ScalarFunction::Digest => "Digest", - ScalarFunction::Exp => "Exp", - ScalarFunction::Floor => "Floor", - ScalarFunction::Ln => "Ln", - ScalarFunction::Log => "Log", - ScalarFunction::Log10 => "Log10", - ScalarFunction::Log2 => "Log2", - ScalarFunction::Round => "Round", - ScalarFunction::Signum => "Signum", - ScalarFunction::Sin => "Sin", - ScalarFunction::Sqrt => "Sqrt", - ScalarFunction::Tan => "Tan", - ScalarFunction::Trunc => "Trunc", - ScalarFunction::Array => "Array", - ScalarFunction::RegexpMatch => "RegexpMatch", - ScalarFunction::BitLength => "BitLength", - ScalarFunction::Btrim => "Btrim", - ScalarFunction::CharacterLength => "CharacterLength", - ScalarFunction::Chr => "Chr", - ScalarFunction::Concat => "Concat", - ScalarFunction::ConcatWithSeparator => "ConcatWithSeparator", - ScalarFunction::DatePart => "DatePart", - ScalarFunction::DateTrunc => "DateTrunc", - ScalarFunction::InitCap => "InitCap", - ScalarFunction::Left => "Left", - ScalarFunction::Lpad => "Lpad", - ScalarFunction::Lower => "Lower", - ScalarFunction::Ltrim => "Ltrim", - ScalarFunction::Md5 => "MD5", - ScalarFunction::NullIf => "NullIf", - ScalarFunction::OctetLength => "OctetLength", - ScalarFunction::Random => "Random", - ScalarFunction::RegexpReplace => "RegexpReplace", - ScalarFunction::Repeat => "Repeat", - ScalarFunction::Replace => "Replace", - ScalarFunction::Reverse => "Reverse", - ScalarFunction::Right => "Right", - ScalarFunction::Rpad => "Rpad", - ScalarFunction::Rtrim => "Rtrim", - ScalarFunction::Sha224 => "SHA224", - ScalarFunction::Sha256 => "SHA256", - ScalarFunction::Sha384 => "SHA384", - ScalarFunction::Sha512 => "SHA512", - ScalarFunction::SplitPart => "SplitPart", - ScalarFunction::StartsWith => "StartsWith", - ScalarFunction::Strpos => "Strpos", - ScalarFunction::Substr => "Substr", - ScalarFunction::ToHex => "ToHex", - ScalarFunction::ToTimestamp => "ToTimestamp", - ScalarFunction::ToTimestampMillis => "ToTimestampMillis", - ScalarFunction::ToTimestampMicros => "ToTimestampMicros", - ScalarFunction::ToTimestampSeconds => "ToTimestampSeconds", - ScalarFunction::Now => "Now", - ScalarFunction::Translate => "Translate", - ScalarFunction::Trim => "Trim", - ScalarFunction::Upper => "Upper", - ScalarFunction::Coalesce => "Coalesce", - ScalarFunction::Power => "Power", - ScalarFunction::StructFun => "StructFun", - ScalarFunction::FromUnixtime => "FromUnixtime", - ScalarFunction::Atan2 => "Atan2", - ScalarFunction::DateBin => "DateBin", - ScalarFunction::ArrowTypeof => "ArrowTypeof", - ScalarFunction::CurrentDate => "CurrentDate", - ScalarFunction::CurrentTime => "CurrentTime", - ScalarFunction::Uuid => "Uuid", - ScalarFunction::Cbrt => "Cbrt", - ScalarFunction::Acosh => "Acosh", - ScalarFunction::Asinh => "Asinh", - ScalarFunction::Atanh => "Atanh", - ScalarFunction::Sinh => "Sinh", - ScalarFunction::Cosh => "Cosh", - ScalarFunction::Tanh => "Tanh", - ScalarFunction::Pi => "Pi", - ScalarFunction::Degrees => "Degrees", - ScalarFunction::Radians => "Radians", - ScalarFunction::Factorial => "Factorial", - ScalarFunction::Lcm => "Lcm", - ScalarFunction::Gcd => "Gcd", - ScalarFunction::ArrayAppend => "ArrayAppend", - ScalarFunction::ArrayConcat => "ArrayConcat", - ScalarFunction::ArrayDims => "ArrayDims", - ScalarFunction::ArrayFill => "ArrayFill", - ScalarFunction::ArrayLength => "ArrayLength", - ScalarFunction::ArrayNdims => "ArrayNdims", - ScalarFunction::ArrayPosition => "ArrayPosition", - ScalarFunction::ArrayPositions => "ArrayPositions", - ScalarFunction::ArrayPrepend => "ArrayPrepend", - ScalarFunction::ArrayRemove => "ArrayRemove", - ScalarFunction::ArrayReplace => "ArrayReplace", - ScalarFunction::ArrayToString => "ArrayToString", - ScalarFunction::Cardinality => "Cardinality", - ScalarFunction::TrimArray => "TrimArray", - ScalarFunction::Encode => "Encode", - ScalarFunction::Decode => "Decode", - ScalarFunction::Cot => "Cot", - ScalarFunction::ArrayHas => "ArrayHas", - ScalarFunction::ArrayHasAny => "ArrayHasAny", - ScalarFunction::ArrayHasAll => "ArrayHasAll", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "Abs" => Some(Self::Abs), - "Acos" => Some(Self::Acos), - "Asin" => Some(Self::Asin), - "Atan" => Some(Self::Atan), - "Ascii" => Some(Self::Ascii), - "Ceil" => Some(Self::Ceil), - "Cos" => Some(Self::Cos), - "Digest" => Some(Self::Digest), - "Exp" => Some(Self::Exp), - "Floor" => Some(Self::Floor), - "Ln" => Some(Self::Ln), - "Log" => Some(Self::Log), - "Log10" => Some(Self::Log10), - "Log2" => Some(Self::Log2), - "Round" => Some(Self::Round), - "Signum" => Some(Self::Signum), - "Sin" => Some(Self::Sin), - "Sqrt" => Some(Self::Sqrt), - "Tan" => Some(Self::Tan), - "Trunc" => Some(Self::Trunc), - "Array" => Some(Self::Array), - "RegexpMatch" => Some(Self::RegexpMatch), - "BitLength" => Some(Self::BitLength), - "Btrim" => Some(Self::Btrim), - "CharacterLength" => Some(Self::CharacterLength), - "Chr" => Some(Self::Chr), - "Concat" => Some(Self::Concat), - "ConcatWithSeparator" => Some(Self::ConcatWithSeparator), - "DatePart" => Some(Self::DatePart), - "DateTrunc" => Some(Self::DateTrunc), - "InitCap" => Some(Self::InitCap), - "Left" => Some(Self::Left), - "Lpad" => Some(Self::Lpad), - "Lower" => Some(Self::Lower), - "Ltrim" => Some(Self::Ltrim), - "MD5" => Some(Self::Md5), - "NullIf" => Some(Self::NullIf), - "OctetLength" => Some(Self::OctetLength), - "Random" => Some(Self::Random), - "RegexpReplace" => Some(Self::RegexpReplace), - "Repeat" => Some(Self::Repeat), - "Replace" => Some(Self::Replace), - "Reverse" => Some(Self::Reverse), - "Right" => Some(Self::Right), - "Rpad" => Some(Self::Rpad), - "Rtrim" => Some(Self::Rtrim), - "SHA224" => Some(Self::Sha224), - "SHA256" => Some(Self::Sha256), - "SHA384" => Some(Self::Sha384), - "SHA512" => Some(Self::Sha512), - "SplitPart" => Some(Self::SplitPart), - "StartsWith" => Some(Self::StartsWith), - "Strpos" => Some(Self::Strpos), - "Substr" => Some(Self::Substr), - "ToHex" => Some(Self::ToHex), - "ToTimestamp" => Some(Self::ToTimestamp), - "ToTimestampMillis" => Some(Self::ToTimestampMillis), - "ToTimestampMicros" => Some(Self::ToTimestampMicros), - "ToTimestampSeconds" => Some(Self::ToTimestampSeconds), - "Now" => Some(Self::Now), - "Translate" => Some(Self::Translate), - "Trim" => Some(Self::Trim), - "Upper" => Some(Self::Upper), - "Coalesce" => Some(Self::Coalesce), - "Power" => Some(Self::Power), - "StructFun" => Some(Self::StructFun), - "FromUnixtime" => Some(Self::FromUnixtime), - "Atan2" => Some(Self::Atan2), - "DateBin" => Some(Self::DateBin), - "ArrowTypeof" => Some(Self::ArrowTypeof), - "CurrentDate" => Some(Self::CurrentDate), - "CurrentTime" => Some(Self::CurrentTime), - "Uuid" => Some(Self::Uuid), - "Cbrt" => Some(Self::Cbrt), - "Acosh" => Some(Self::Acosh), - "Asinh" => Some(Self::Asinh), - "Atanh" => Some(Self::Atanh), - "Sinh" => Some(Self::Sinh), - "Cosh" => Some(Self::Cosh), - "Tanh" => Some(Self::Tanh), - "Pi" => Some(Self::Pi), - "Degrees" => Some(Self::Degrees), - "Radians" => Some(Self::Radians), - "Factorial" => Some(Self::Factorial), - "Lcm" => Some(Self::Lcm), - "Gcd" => Some(Self::Gcd), - "ArrayAppend" => Some(Self::ArrayAppend), - "ArrayConcat" => Some(Self::ArrayConcat), - "ArrayDims" => Some(Self::ArrayDims), - "ArrayFill" => Some(Self::ArrayFill), - "ArrayLength" => Some(Self::ArrayLength), - "ArrayNdims" => Some(Self::ArrayNdims), - "ArrayPosition" => Some(Self::ArrayPosition), - "ArrayPositions" => Some(Self::ArrayPositions), - "ArrayPrepend" => Some(Self::ArrayPrepend), - "ArrayRemove" => Some(Self::ArrayRemove), - "ArrayReplace" => Some(Self::ArrayReplace), - "ArrayToString" => Some(Self::ArrayToString), - "Cardinality" => Some(Self::Cardinality), - "TrimArray" => Some(Self::TrimArray), - "Encode" => Some(Self::Encode), - "Decode" => Some(Self::Decode), - "Cot" => Some(Self::Cot), - "ArrayHas" => Some(Self::ArrayHas), - "ArrayHasAny" => Some(Self::ArrayHasAny), - "ArrayHasAll" => Some(Self::ArrayHasAll), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum AggregateFunction { - Min = 0, - Max = 1, - Sum = 2, - Avg = 3, - Count = 4, - ApproxDistinct = 5, - ArrayAgg = 6, - Variance = 7, - VariancePop = 8, - Covariance = 9, - CovariancePop = 10, - Stddev = 11, - StddevPop = 12, - Correlation = 13, - ApproxPercentileCont = 14, - ApproxMedian = 15, - ApproxPercentileContWithWeight = 16, - Grouping = 17, - Median = 18, - BitAnd = 19, - BitOr = 20, - BitXor = 21, - BoolAnd = 22, - BoolOr = 23, - /// When a function with the same name exists among built-in window functions, - /// we append "_AGG" to obey name scoping rules. - FirstValueAgg = 24, - LastValueAgg = 25, -} -impl AggregateFunction { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - AggregateFunction::Min => "MIN", - AggregateFunction::Max => "MAX", - AggregateFunction::Sum => "SUM", - AggregateFunction::Avg => "AVG", - AggregateFunction::Count => "COUNT", - AggregateFunction::ApproxDistinct => "APPROX_DISTINCT", - AggregateFunction::ArrayAgg => "ARRAY_AGG", - AggregateFunction::Variance => "VARIANCE", - AggregateFunction::VariancePop => "VARIANCE_POP", - AggregateFunction::Covariance => "COVARIANCE", - AggregateFunction::CovariancePop => "COVARIANCE_POP", - AggregateFunction::Stddev => "STDDEV", - AggregateFunction::StddevPop => "STDDEV_POP", - AggregateFunction::Correlation => "CORRELATION", - AggregateFunction::ApproxPercentileCont => "APPROX_PERCENTILE_CONT", - AggregateFunction::ApproxMedian => "APPROX_MEDIAN", - AggregateFunction::ApproxPercentileContWithWeight => { - "APPROX_PERCENTILE_CONT_WITH_WEIGHT" - } - AggregateFunction::Grouping => "GROUPING", - AggregateFunction::Median => "MEDIAN", - AggregateFunction::BitAnd => "BIT_AND", - AggregateFunction::BitOr => "BIT_OR", - AggregateFunction::BitXor => "BIT_XOR", - AggregateFunction::BoolAnd => "BOOL_AND", - AggregateFunction::BoolOr => "BOOL_OR", - AggregateFunction::FirstValueAgg => "FIRST_VALUE_AGG", - AggregateFunction::LastValueAgg => "LAST_VALUE_AGG", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "MIN" => Some(Self::Min), - "MAX" => Some(Self::Max), - "SUM" => Some(Self::Sum), - "AVG" => Some(Self::Avg), - "COUNT" => Some(Self::Count), - "APPROX_DISTINCT" => Some(Self::ApproxDistinct), - "ARRAY_AGG" => Some(Self::ArrayAgg), - "VARIANCE" => Some(Self::Variance), - "VARIANCE_POP" => Some(Self::VariancePop), - "COVARIANCE" => Some(Self::Covariance), - "COVARIANCE_POP" => Some(Self::CovariancePop), - "STDDEV" => Some(Self::Stddev), - "STDDEV_POP" => Some(Self::StddevPop), - "CORRELATION" => Some(Self::Correlation), - "APPROX_PERCENTILE_CONT" => Some(Self::ApproxPercentileCont), - "APPROX_MEDIAN" => Some(Self::ApproxMedian), - "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => { - Some(Self::ApproxPercentileContWithWeight) - } - "GROUPING" => Some(Self::Grouping), - "MEDIAN" => Some(Self::Median), - "BIT_AND" => Some(Self::BitAnd), - "BIT_OR" => Some(Self::BitOr), - "BIT_XOR" => Some(Self::BitXor), - "BOOL_AND" => Some(Self::BoolAnd), - "BOOL_OR" => Some(Self::BoolOr), - "FIRST_VALUE_AGG" => Some(Self::FirstValueAgg), - "LAST_VALUE_AGG" => Some(Self::LastValueAgg), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum BuiltInWindowFunction { - RowNumber = 0, - Rank = 1, - DenseRank = 2, - PercentRank = 3, - CumeDist = 4, - Ntile = 5, - Lag = 6, - Lead = 7, - FirstValue = 8, - LastValue = 9, - NthValue = 10, -} -impl BuiltInWindowFunction { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - BuiltInWindowFunction::RowNumber => "ROW_NUMBER", - BuiltInWindowFunction::Rank => "RANK", - BuiltInWindowFunction::DenseRank => "DENSE_RANK", - BuiltInWindowFunction::PercentRank => "PERCENT_RANK", - BuiltInWindowFunction::CumeDist => "CUME_DIST", - BuiltInWindowFunction::Ntile => "NTILE", - BuiltInWindowFunction::Lag => "LAG", - BuiltInWindowFunction::Lead => "LEAD", - BuiltInWindowFunction::FirstValue => "FIRST_VALUE", - BuiltInWindowFunction::LastValue => "LAST_VALUE", - BuiltInWindowFunction::NthValue => "NTH_VALUE", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "ROW_NUMBER" => Some(Self::RowNumber), - "RANK" => Some(Self::Rank), - "DENSE_RANK" => Some(Self::DenseRank), - "PERCENT_RANK" => Some(Self::PercentRank), - "CUME_DIST" => Some(Self::CumeDist), - "NTILE" => Some(Self::Ntile), - "LAG" => Some(Self::Lag), - "LEAD" => Some(Self::Lead), - "FIRST_VALUE" => Some(Self::FirstValue), - "LAST_VALUE" => Some(Self::LastValue), - "NTH_VALUE" => Some(Self::NthValue), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum WindowFrameUnits { - Rows = 0, - Range = 1, - Groups = 2, -} -impl WindowFrameUnits { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - WindowFrameUnits::Rows => "ROWS", - WindowFrameUnits::Range => "RANGE", - WindowFrameUnits::Groups => "GROUPS", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "ROWS" => Some(Self::Rows), - "RANGE" => Some(Self::Range), - "GROUPS" => Some(Self::Groups), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum WindowFrameBoundType { - CurrentRow = 0, - Preceding = 1, - Following = 2, -} -impl WindowFrameBoundType { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - WindowFrameBoundType::CurrentRow => "CURRENT_ROW", - WindowFrameBoundType::Preceding => "PRECEDING", - WindowFrameBoundType::Following => "FOLLOWING", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "CURRENT_ROW" => Some(Self::CurrentRow), - "PRECEDING" => Some(Self::Preceding), - "FOLLOWING" => Some(Self::Following), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum DateUnit { - Day = 0, - DateMillisecond = 1, -} -impl DateUnit { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - DateUnit::Day => "Day", - DateUnit::DateMillisecond => "DateMillisecond", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "Day" => Some(Self::Day), - "DateMillisecond" => Some(Self::DateMillisecond), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum TimeUnit { - Second = 0, - Millisecond = 1, - Microsecond = 2, - Nanosecond = 3, -} -impl TimeUnit { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - TimeUnit::Second => "Second", - TimeUnit::Millisecond => "Millisecond", - TimeUnit::Microsecond => "Microsecond", - TimeUnit::Nanosecond => "Nanosecond", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "Second" => Some(Self::Second), - "Millisecond" => Some(Self::Millisecond), - "Microsecond" => Some(Self::Microsecond), - "Nanosecond" => Some(Self::Nanosecond), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum IntervalUnit { - YearMonth = 0, - DayTime = 1, - MonthDayNano = 2, -} -impl IntervalUnit { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - IntervalUnit::YearMonth => "YearMonth", - IntervalUnit::DayTime => "DayTime", - IntervalUnit::MonthDayNano => "MonthDayNano", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "YearMonth" => Some(Self::YearMonth), - "DayTime" => Some(Self::DayTime), - "MonthDayNano" => Some(Self::MonthDayNano), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum UnionMode { - Sparse = 0, - Dense = 1, -} -impl UnionMode { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - UnionMode::Sparse => "sparse", - UnionMode::Dense => "dense", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "sparse" => Some(Self::Sparse), - "dense" => Some(Self::Dense), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum PartitionMode { - CollectLeft = 0, - Partitioned = 1, - Auto = 2, -} -impl PartitionMode { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - PartitionMode::CollectLeft => "COLLECT_LEFT", - PartitionMode::Partitioned => "PARTITIONED", - PartitionMode::Auto => "AUTO", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "COLLECT_LEFT" => Some(Self::CollectLeft), - "PARTITIONED" => Some(Self::Partitioned), - "AUTO" => Some(Self::Auto), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum AggregateMode { - Partial = 0, - Final = 1, - FinalPartitioned = 2, - Single = 3, - SinglePartitioned = 4, -} -impl AggregateMode { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - AggregateMode::Partial => "PARTIAL", - AggregateMode::Final => "FINAL", - AggregateMode::FinalPartitioned => "FINAL_PARTITIONED", - AggregateMode::Single => "SINGLE", - AggregateMode::SinglePartitioned => "SINGLE_PARTITIONED", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "PARTIAL" => Some(Self::Partial), - "FINAL" => Some(Self::Final), - "FINAL_PARTITIONED" => Some(Self::FinalPartitioned), - "SINGLE" => Some(Self::Single), - "SINGLE_PARTITIONED" => Some(Self::SinglePartitioned), - _ => None, - } - } -} -#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] -#[repr(i32)] -pub enum JoinSide { - LeftSide = 0, - RightSide = 1, -} -impl JoinSide { - /// String value of the enum field names used in the ProtoBuf definition. - /// - /// The values are not transformed in any way and thus are considered stable - /// (if the ProtoBuf definition does not change) and safe for programmatic use. - pub fn as_str_name(&self) -> &'static str { - match self { - JoinSide::LeftSide => "LEFT_SIDE", - JoinSide::RightSide => "RIGHT_SIDE", - } - } - /// Creates an enum from field names used in the ProtoBuf definition. - pub fn from_str_name(value: &str) -> ::core::option::Option { - match value { - "LEFT_SIDE" => Some(Self::LeftSide), - "RIGHT_SIDE" => Some(Self::RightSide), - _ => None, - } - } -} diff --git a/datafusion/proto/src/datafusion.serde.rs b/datafusion/proto/src/datafusion.serde.rs deleted file mode 100644 index 05bfbd089dfe..000000000000 --- a/datafusion/proto/src/datafusion.serde.rs +++ /dev/null @@ -1,23148 +0,0 @@ -impl serde::Serialize for AggregateExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.group_expr.is_empty() { - len += 1; - } - if !self.aggr_expr.is_empty() { - len += 1; - } - if self.mode != 0 { - len += 1; - } - if self.input.is_some() { - len += 1; - } - if !self.group_expr_name.is_empty() { - len += 1; - } - if !self.aggr_expr_name.is_empty() { - len += 1; - } - if self.input_schema.is_some() { - len += 1; - } - if !self.null_expr.is_empty() { - len += 1; - } - if !self.groups.is_empty() { - len += 1; - } - if !self.filter_expr.is_empty() { - len += 1; - } - if !self.order_by_expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExecNode", len)?; - if !self.group_expr.is_empty() { - struct_ser.serialize_field("groupExpr", &self.group_expr)?; - } - if !self.aggr_expr.is_empty() { - struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?; - } - if self.mode != 0 { - let v = AggregateMode::from_i32(self.mode) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.mode)))?; - struct_ser.serialize_field("mode", &v)?; - } - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.group_expr_name.is_empty() { - struct_ser.serialize_field("groupExprName", &self.group_expr_name)?; - } - if !self.aggr_expr_name.is_empty() { - struct_ser.serialize_field("aggrExprName", &self.aggr_expr_name)?; - } - if let Some(v) = self.input_schema.as_ref() { - struct_ser.serialize_field("inputSchema", v)?; - } - if !self.null_expr.is_empty() { - struct_ser.serialize_field("nullExpr", &self.null_expr)?; - } - if !self.groups.is_empty() { - struct_ser.serialize_field("groups", &self.groups)?; - } - if !self.filter_expr.is_empty() { - struct_ser.serialize_field("filterExpr", &self.filter_expr)?; - } - if !self.order_by_expr.is_empty() { - struct_ser.serialize_field("orderByExpr", &self.order_by_expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AggregateExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "group_expr", - "groupExpr", - "aggr_expr", - "aggrExpr", - "mode", - "input", - "group_expr_name", - "groupExprName", - "aggr_expr_name", - "aggrExprName", - "input_schema", - "inputSchema", - "null_expr", - "nullExpr", - "groups", - "filter_expr", - "filterExpr", - "order_by_expr", - "orderByExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - GroupExpr, - AggrExpr, - Mode, - Input, - GroupExprName, - AggrExprName, - InputSchema, - NullExpr, - Groups, - FilterExpr, - OrderByExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr), - "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr), - "mode" => Ok(GeneratedField::Mode), - "input" => Ok(GeneratedField::Input), - "groupExprName" | "group_expr_name" => Ok(GeneratedField::GroupExprName), - "aggrExprName" | "aggr_expr_name" => Ok(GeneratedField::AggrExprName), - "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema), - "nullExpr" | "null_expr" => Ok(GeneratedField::NullExpr), - "groups" => Ok(GeneratedField::Groups), - "filterExpr" | "filter_expr" => Ok(GeneratedField::FilterExpr), - "orderByExpr" | "order_by_expr" => Ok(GeneratedField::OrderByExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AggregateExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AggregateExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut group_expr__ = None; - let mut aggr_expr__ = None; - let mut mode__ = None; - let mut input__ = None; - let mut group_expr_name__ = None; - let mut aggr_expr_name__ = None; - let mut input_schema__ = None; - let mut null_expr__ = None; - let mut groups__ = None; - let mut filter_expr__ = None; - let mut order_by_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::GroupExpr => { - if group_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("groupExpr")); - } - group_expr__ = Some(map.next_value()?); - } - GeneratedField::AggrExpr => { - if aggr_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("aggrExpr")); - } - aggr_expr__ = Some(map.next_value()?); - } - GeneratedField::Mode => { - if mode__.is_some() { - return Err(serde::de::Error::duplicate_field("mode")); - } - mode__ = Some(map.next_value::()? as i32); - } - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::GroupExprName => { - if group_expr_name__.is_some() { - return Err(serde::de::Error::duplicate_field("groupExprName")); - } - group_expr_name__ = Some(map.next_value()?); - } - GeneratedField::AggrExprName => { - if aggr_expr_name__.is_some() { - return Err(serde::de::Error::duplicate_field("aggrExprName")); - } - aggr_expr_name__ = Some(map.next_value()?); - } - GeneratedField::InputSchema => { - if input_schema__.is_some() { - return Err(serde::de::Error::duplicate_field("inputSchema")); - } - input_schema__ = map.next_value()?; - } - GeneratedField::NullExpr => { - if null_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("nullExpr")); - } - null_expr__ = Some(map.next_value()?); - } - GeneratedField::Groups => { - if groups__.is_some() { - return Err(serde::de::Error::duplicate_field("groups")); - } - groups__ = Some(map.next_value()?); - } - GeneratedField::FilterExpr => { - if filter_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("filterExpr")); - } - filter_expr__ = Some(map.next_value()?); - } - GeneratedField::OrderByExpr => { - if order_by_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("orderByExpr")); - } - order_by_expr__ = Some(map.next_value()?); - } - } - } - Ok(AggregateExecNode { - group_expr: group_expr__.unwrap_or_default(), - aggr_expr: aggr_expr__.unwrap_or_default(), - mode: mode__.unwrap_or_default(), - input: input__, - group_expr_name: group_expr_name__.unwrap_or_default(), - aggr_expr_name: aggr_expr_name__.unwrap_or_default(), - input_schema: input_schema__, - null_expr: null_expr__.unwrap_or_default(), - groups: groups__.unwrap_or_default(), - filter_expr: filter_expr__.unwrap_or_default(), - order_by_expr: order_by_expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.AggregateExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AggregateExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.aggr_function != 0 { - len += 1; - } - if !self.expr.is_empty() { - len += 1; - } - if self.distinct { - len += 1; - } - if self.filter.is_some() { - len += 1; - } - if !self.order_by.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AggregateExprNode", len)?; - if self.aggr_function != 0 { - let v = AggregateFunction::from_i32(self.aggr_function) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.aggr_function)))?; - struct_ser.serialize_field("aggrFunction", &v)?; - } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if self.distinct { - struct_ser.serialize_field("distinct", &self.distinct)?; - } - if let Some(v) = self.filter.as_ref() { - struct_ser.serialize_field("filter", v)?; - } - if !self.order_by.is_empty() { - struct_ser.serialize_field("orderBy", &self.order_by)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AggregateExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "aggr_function", - "aggrFunction", - "expr", - "distinct", - "filter", - "order_by", - "orderBy", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - AggrFunction, - Expr, - Distinct, - Filter, - OrderBy, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction), - "expr" => Ok(GeneratedField::Expr), - "distinct" => Ok(GeneratedField::Distinct), - "filter" => Ok(GeneratedField::Filter), - "orderBy" | "order_by" => Ok(GeneratedField::OrderBy), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AggregateExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AggregateExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut aggr_function__ = None; - let mut expr__ = None; - let mut distinct__ = None; - let mut filter__ = None; - let mut order_by__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::AggrFunction => { - if aggr_function__.is_some() { - return Err(serde::de::Error::duplicate_field("aggrFunction")); - } - aggr_function__ = Some(map.next_value::()? as i32); - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - GeneratedField::Distinct => { - if distinct__.is_some() { - return Err(serde::de::Error::duplicate_field("distinct")); - } - distinct__ = Some(map.next_value()?); - } - GeneratedField::Filter => { - if filter__.is_some() { - return Err(serde::de::Error::duplicate_field("filter")); - } - filter__ = map.next_value()?; - } - GeneratedField::OrderBy => { - if order_by__.is_some() { - return Err(serde::de::Error::duplicate_field("orderBy")); - } - order_by__ = Some(map.next_value()?); - } - } - } - Ok(AggregateExprNode { - aggr_function: aggr_function__.unwrap_or_default(), - expr: expr__.unwrap_or_default(), - distinct: distinct__.unwrap_or_default(), - filter: filter__, - order_by: order_by__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.AggregateExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AggregateFunction { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Min => "MIN", - Self::Max => "MAX", - Self::Sum => "SUM", - Self::Avg => "AVG", - Self::Count => "COUNT", - Self::ApproxDistinct => "APPROX_DISTINCT", - Self::ArrayAgg => "ARRAY_AGG", - Self::Variance => "VARIANCE", - Self::VariancePop => "VARIANCE_POP", - Self::Covariance => "COVARIANCE", - Self::CovariancePop => "COVARIANCE_POP", - Self::Stddev => "STDDEV", - Self::StddevPop => "STDDEV_POP", - Self::Correlation => "CORRELATION", - Self::ApproxPercentileCont => "APPROX_PERCENTILE_CONT", - Self::ApproxMedian => "APPROX_MEDIAN", - Self::ApproxPercentileContWithWeight => "APPROX_PERCENTILE_CONT_WITH_WEIGHT", - Self::Grouping => "GROUPING", - Self::Median => "MEDIAN", - Self::BitAnd => "BIT_AND", - Self::BitOr => "BIT_OR", - Self::BitXor => "BIT_XOR", - Self::BoolAnd => "BOOL_AND", - Self::BoolOr => "BOOL_OR", - Self::FirstValueAgg => "FIRST_VALUE_AGG", - Self::LastValueAgg => "LAST_VALUE_AGG", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for AggregateFunction { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "MIN", - "MAX", - "SUM", - "AVG", - "COUNT", - "APPROX_DISTINCT", - "ARRAY_AGG", - "VARIANCE", - "VARIANCE_POP", - "COVARIANCE", - "COVARIANCE_POP", - "STDDEV", - "STDDEV_POP", - "CORRELATION", - "APPROX_PERCENTILE_CONT", - "APPROX_MEDIAN", - "APPROX_PERCENTILE_CONT_WITH_WEIGHT", - "GROUPING", - "MEDIAN", - "BIT_AND", - "BIT_OR", - "BIT_XOR", - "BOOL_AND", - "BOOL_OR", - "FIRST_VALUE_AGG", - "LAST_VALUE_AGG", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AggregateFunction; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(AggregateFunction::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(AggregateFunction::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "MIN" => Ok(AggregateFunction::Min), - "MAX" => Ok(AggregateFunction::Max), - "SUM" => Ok(AggregateFunction::Sum), - "AVG" => Ok(AggregateFunction::Avg), - "COUNT" => Ok(AggregateFunction::Count), - "APPROX_DISTINCT" => Ok(AggregateFunction::ApproxDistinct), - "ARRAY_AGG" => Ok(AggregateFunction::ArrayAgg), - "VARIANCE" => Ok(AggregateFunction::Variance), - "VARIANCE_POP" => Ok(AggregateFunction::VariancePop), - "COVARIANCE" => Ok(AggregateFunction::Covariance), - "COVARIANCE_POP" => Ok(AggregateFunction::CovariancePop), - "STDDEV" => Ok(AggregateFunction::Stddev), - "STDDEV_POP" => Ok(AggregateFunction::StddevPop), - "CORRELATION" => Ok(AggregateFunction::Correlation), - "APPROX_PERCENTILE_CONT" => Ok(AggregateFunction::ApproxPercentileCont), - "APPROX_MEDIAN" => Ok(AggregateFunction::ApproxMedian), - "APPROX_PERCENTILE_CONT_WITH_WEIGHT" => Ok(AggregateFunction::ApproxPercentileContWithWeight), - "GROUPING" => Ok(AggregateFunction::Grouping), - "MEDIAN" => Ok(AggregateFunction::Median), - "BIT_AND" => Ok(AggregateFunction::BitAnd), - "BIT_OR" => Ok(AggregateFunction::BitOr), - "BIT_XOR" => Ok(AggregateFunction::BitXor), - "BOOL_AND" => Ok(AggregateFunction::BoolAnd), - "BOOL_OR" => Ok(AggregateFunction::BoolOr), - "FIRST_VALUE_AGG" => Ok(AggregateFunction::FirstValueAgg), - "LAST_VALUE_AGG" => Ok(AggregateFunction::LastValueAgg), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for AggregateMode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Partial => "PARTIAL", - Self::Final => "FINAL", - Self::FinalPartitioned => "FINAL_PARTITIONED", - Self::Single => "SINGLE", - Self::SinglePartitioned => "SINGLE_PARTITIONED", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for AggregateMode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "PARTIAL", - "FINAL", - "FINAL_PARTITIONED", - "SINGLE", - "SINGLE_PARTITIONED", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AggregateMode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(AggregateMode::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(AggregateMode::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "PARTIAL" => Ok(AggregateMode::Partial), - "FINAL" => Ok(AggregateMode::Final), - "FINAL_PARTITIONED" => Ok(AggregateMode::FinalPartitioned), - "SINGLE" => Ok(AggregateMode::Single), - "SINGLE_PARTITIONED" => Ok(AggregateMode::SinglePartitioned), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for AggregateNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.group_expr.is_empty() { - len += 1; - } - if !self.aggr_expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AggregateNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.group_expr.is_empty() { - struct_ser.serialize_field("groupExpr", &self.group_expr)?; - } - if !self.aggr_expr.is_empty() { - struct_ser.serialize_field("aggrExpr", &self.aggr_expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AggregateNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "group_expr", - "groupExpr", - "aggr_expr", - "aggrExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - GroupExpr, - AggrExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "groupExpr" | "group_expr" => Ok(GeneratedField::GroupExpr), - "aggrExpr" | "aggr_expr" => Ok(GeneratedField::AggrExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AggregateNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AggregateNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut group_expr__ = None; - let mut aggr_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::GroupExpr => { - if group_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("groupExpr")); - } - group_expr__ = Some(map.next_value()?); - } - GeneratedField::AggrExpr => { - if aggr_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("aggrExpr")); - } - aggr_expr__ = Some(map.next_value()?); - } - } - } - Ok(AggregateNode { - input: input__, - group_expr: group_expr__.unwrap_or_default(), - aggr_expr: aggr_expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.AggregateNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AggregateUdfExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.fun_name.is_empty() { - len += 1; - } - if !self.args.is_empty() { - len += 1; - } - if self.filter.is_some() { - len += 1; - } - if !self.order_by.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AggregateUDFExprNode", len)?; - if !self.fun_name.is_empty() { - struct_ser.serialize_field("funName", &self.fun_name)?; - } - if !self.args.is_empty() { - struct_ser.serialize_field("args", &self.args)?; - } - if let Some(v) = self.filter.as_ref() { - struct_ser.serialize_field("filter", v)?; - } - if !self.order_by.is_empty() { - struct_ser.serialize_field("orderBy", &self.order_by)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AggregateUdfExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "fun_name", - "funName", - "args", - "filter", - "order_by", - "orderBy", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - FunName, - Args, - Filter, - OrderBy, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "funName" | "fun_name" => Ok(GeneratedField::FunName), - "args" => Ok(GeneratedField::Args), - "filter" => Ok(GeneratedField::Filter), - "orderBy" | "order_by" => Ok(GeneratedField::OrderBy), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AggregateUdfExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AggregateUDFExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut fun_name__ = None; - let mut args__ = None; - let mut filter__ = None; - let mut order_by__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::FunName => { - if fun_name__.is_some() { - return Err(serde::de::Error::duplicate_field("funName")); - } - fun_name__ = Some(map.next_value()?); - } - GeneratedField::Args => { - if args__.is_some() { - return Err(serde::de::Error::duplicate_field("args")); - } - args__ = Some(map.next_value()?); - } - GeneratedField::Filter => { - if filter__.is_some() { - return Err(serde::de::Error::duplicate_field("filter")); - } - filter__ = map.next_value()?; - } - GeneratedField::OrderBy => { - if order_by__.is_some() { - return Err(serde::de::Error::duplicate_field("orderBy")); - } - order_by__ = Some(map.next_value()?); - } - } - } - Ok(AggregateUdfExprNode { - fun_name: fun_name__.unwrap_or_default(), - args: args__.unwrap_or_default(), - filter: filter__, - order_by: order_by__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.AggregateUDFExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AliasNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if !self.alias.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AliasNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if !self.alias.is_empty() { - struct_ser.serialize_field("alias", &self.alias)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AliasNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "alias", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - Alias, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "alias" => Ok(GeneratedField::Alias), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AliasNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AliasNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut alias__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Alias => { - if alias__.is_some() { - return Err(serde::de::Error::duplicate_field("alias")); - } - alias__ = Some(map.next_value()?); - } - } - } - Ok(AliasNode { - expr: expr__, - alias: alias__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.AliasNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AnalyzeNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.verbose { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AnalyzeNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.verbose { - struct_ser.serialize_field("verbose", &self.verbose)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AnalyzeNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "verbose", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Verbose, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "verbose" => Ok(GeneratedField::Verbose), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AnalyzeNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AnalyzeNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut verbose__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Verbose => { - if verbose__.is_some() { - return Err(serde::de::Error::duplicate_field("verbose")); - } - verbose__ = Some(map.next_value()?); - } - } - } - Ok(AnalyzeNode { - input: input__, - verbose: verbose__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.AnalyzeNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AnalyzedLogicalPlanType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.analyzer_name.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AnalyzedLogicalPlanType", len)?; - if !self.analyzer_name.is_empty() { - struct_ser.serialize_field("analyzerName", &self.analyzer_name)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AnalyzedLogicalPlanType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "analyzer_name", - "analyzerName", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - AnalyzerName, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "analyzerName" | "analyzer_name" => Ok(GeneratedField::AnalyzerName), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AnalyzedLogicalPlanType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AnalyzedLogicalPlanType") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut analyzer_name__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::AnalyzerName => { - if analyzer_name__.is_some() { - return Err(serde::de::Error::duplicate_field("analyzerName")); - } - analyzer_name__ = Some(map.next_value()?); - } - } - } - Ok(AnalyzedLogicalPlanType { - analyzer_name: analyzer_name__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.AnalyzedLogicalPlanType", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ArrowType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.arrow_type_enum.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ArrowType", len)?; - if let Some(v) = self.arrow_type_enum.as_ref() { - match v { - arrow_type::ArrowTypeEnum::None(v) => { - struct_ser.serialize_field("NONE", v)?; - } - arrow_type::ArrowTypeEnum::Bool(v) => { - struct_ser.serialize_field("BOOL", v)?; - } - arrow_type::ArrowTypeEnum::Uint8(v) => { - struct_ser.serialize_field("UINT8", v)?; - } - arrow_type::ArrowTypeEnum::Int8(v) => { - struct_ser.serialize_field("INT8", v)?; - } - arrow_type::ArrowTypeEnum::Uint16(v) => { - struct_ser.serialize_field("UINT16", v)?; - } - arrow_type::ArrowTypeEnum::Int16(v) => { - struct_ser.serialize_field("INT16", v)?; - } - arrow_type::ArrowTypeEnum::Uint32(v) => { - struct_ser.serialize_field("UINT32", v)?; - } - arrow_type::ArrowTypeEnum::Int32(v) => { - struct_ser.serialize_field("INT32", v)?; - } - arrow_type::ArrowTypeEnum::Uint64(v) => { - struct_ser.serialize_field("UINT64", v)?; - } - arrow_type::ArrowTypeEnum::Int64(v) => { - struct_ser.serialize_field("INT64", v)?; - } - arrow_type::ArrowTypeEnum::Float16(v) => { - struct_ser.serialize_field("FLOAT16", v)?; - } - arrow_type::ArrowTypeEnum::Float32(v) => { - struct_ser.serialize_field("FLOAT32", v)?; - } - arrow_type::ArrowTypeEnum::Float64(v) => { - struct_ser.serialize_field("FLOAT64", v)?; - } - arrow_type::ArrowTypeEnum::Utf8(v) => { - struct_ser.serialize_field("UTF8", v)?; - } - arrow_type::ArrowTypeEnum::LargeUtf8(v) => { - struct_ser.serialize_field("LARGEUTF8", v)?; - } - arrow_type::ArrowTypeEnum::Binary(v) => { - struct_ser.serialize_field("BINARY", v)?; - } - arrow_type::ArrowTypeEnum::FixedSizeBinary(v) => { - struct_ser.serialize_field("FIXEDSIZEBINARY", v)?; - } - arrow_type::ArrowTypeEnum::LargeBinary(v) => { - struct_ser.serialize_field("LARGEBINARY", v)?; - } - arrow_type::ArrowTypeEnum::Date32(v) => { - struct_ser.serialize_field("DATE32", v)?; - } - arrow_type::ArrowTypeEnum::Date64(v) => { - struct_ser.serialize_field("DATE64", v)?; - } - arrow_type::ArrowTypeEnum::Duration(v) => { - let v = TimeUnit::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("DURATION", &v)?; - } - arrow_type::ArrowTypeEnum::Timestamp(v) => { - struct_ser.serialize_field("TIMESTAMP", v)?; - } - arrow_type::ArrowTypeEnum::Time32(v) => { - let v = TimeUnit::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("TIME32", &v)?; - } - arrow_type::ArrowTypeEnum::Time64(v) => { - let v = TimeUnit::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("TIME64", &v)?; - } - arrow_type::ArrowTypeEnum::Interval(v) => { - let v = IntervalUnit::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("INTERVAL", &v)?; - } - arrow_type::ArrowTypeEnum::Decimal(v) => { - struct_ser.serialize_field("DECIMAL", v)?; - } - arrow_type::ArrowTypeEnum::List(v) => { - struct_ser.serialize_field("LIST", v)?; - } - arrow_type::ArrowTypeEnum::LargeList(v) => { - struct_ser.serialize_field("LARGELIST", v)?; - } - arrow_type::ArrowTypeEnum::FixedSizeList(v) => { - struct_ser.serialize_field("FIXEDSIZELIST", v)?; - } - arrow_type::ArrowTypeEnum::Struct(v) => { - struct_ser.serialize_field("STRUCT", v)?; - } - arrow_type::ArrowTypeEnum::Union(v) => { - struct_ser.serialize_field("UNION", v)?; - } - arrow_type::ArrowTypeEnum::Dictionary(v) => { - struct_ser.serialize_field("DICTIONARY", v)?; - } - arrow_type::ArrowTypeEnum::Map(v) => { - struct_ser.serialize_field("MAP", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ArrowType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "NONE", - "BOOL", - "UINT8", - "INT8", - "UINT16", - "INT16", - "UINT32", - "INT32", - "UINT64", - "INT64", - "FLOAT16", - "FLOAT32", - "FLOAT64", - "UTF8", - "LARGE_UTF8", - "LARGEUTF8", - "BINARY", - "FIXED_SIZE_BINARY", - "FIXEDSIZEBINARY", - "LARGE_BINARY", - "LARGEBINARY", - "DATE32", - "DATE64", - "DURATION", - "TIMESTAMP", - "TIME32", - "TIME64", - "INTERVAL", - "DECIMAL", - "LIST", - "LARGE_LIST", - "LARGELIST", - "FIXED_SIZE_LIST", - "FIXEDSIZELIST", - "STRUCT", - "UNION", - "DICTIONARY", - "MAP", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - None, - Bool, - Uint8, - Int8, - Uint16, - Int16, - Uint32, - Int32, - Uint64, - Int64, - Float16, - Float32, - Float64, - Utf8, - LargeUtf8, - Binary, - FixedSizeBinary, - LargeBinary, - Date32, - Date64, - Duration, - Timestamp, - Time32, - Time64, - Interval, - Decimal, - List, - LargeList, - FixedSizeList, - Struct, - Union, - Dictionary, - Map, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "NONE" => Ok(GeneratedField::None), - "BOOL" => Ok(GeneratedField::Bool), - "UINT8" => Ok(GeneratedField::Uint8), - "INT8" => Ok(GeneratedField::Int8), - "UINT16" => Ok(GeneratedField::Uint16), - "INT16" => Ok(GeneratedField::Int16), - "UINT32" => Ok(GeneratedField::Uint32), - "INT32" => Ok(GeneratedField::Int32), - "UINT64" => Ok(GeneratedField::Uint64), - "INT64" => Ok(GeneratedField::Int64), - "FLOAT16" => Ok(GeneratedField::Float16), - "FLOAT32" => Ok(GeneratedField::Float32), - "FLOAT64" => Ok(GeneratedField::Float64), - "UTF8" => Ok(GeneratedField::Utf8), - "LARGEUTF8" | "LARGE_UTF8" => Ok(GeneratedField::LargeUtf8), - "BINARY" => Ok(GeneratedField::Binary), - "FIXEDSIZEBINARY" | "FIXED_SIZE_BINARY" => Ok(GeneratedField::FixedSizeBinary), - "LARGEBINARY" | "LARGE_BINARY" => Ok(GeneratedField::LargeBinary), - "DATE32" => Ok(GeneratedField::Date32), - "DATE64" => Ok(GeneratedField::Date64), - "DURATION" => Ok(GeneratedField::Duration), - "TIMESTAMP" => Ok(GeneratedField::Timestamp), - "TIME32" => Ok(GeneratedField::Time32), - "TIME64" => Ok(GeneratedField::Time64), - "INTERVAL" => Ok(GeneratedField::Interval), - "DECIMAL" => Ok(GeneratedField::Decimal), - "LIST" => Ok(GeneratedField::List), - "LARGELIST" | "LARGE_LIST" => Ok(GeneratedField::LargeList), - "FIXEDSIZELIST" | "FIXED_SIZE_LIST" => Ok(GeneratedField::FixedSizeList), - "STRUCT" => Ok(GeneratedField::Struct), - "UNION" => Ok(GeneratedField::Union), - "DICTIONARY" => Ok(GeneratedField::Dictionary), - "MAP" => Ok(GeneratedField::Map), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ArrowType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ArrowType") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut arrow_type_enum__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::None => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("NONE")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::None) -; - } - GeneratedField::Bool => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("BOOL")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Bool) -; - } - GeneratedField::Uint8 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("UINT8")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint8) -; - } - GeneratedField::Int8 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("INT8")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int8) -; - } - GeneratedField::Uint16 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("UINT16")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint16) -; - } - GeneratedField::Int16 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("INT16")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int16) -; - } - GeneratedField::Uint32 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("UINT32")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint32) -; - } - GeneratedField::Int32 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("INT32")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int32) -; - } - GeneratedField::Uint64 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("UINT64")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Uint64) -; - } - GeneratedField::Int64 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("INT64")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Int64) -; - } - GeneratedField::Float16 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FLOAT16")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float16) -; - } - GeneratedField::Float32 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FLOAT32")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float32) -; - } - GeneratedField::Float64 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FLOAT64")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Float64) -; - } - GeneratedField::Utf8 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("UTF8")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Utf8) -; - } - GeneratedField::LargeUtf8 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("LARGEUTF8")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeUtf8) -; - } - GeneratedField::Binary => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("BINARY")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Binary) -; - } - GeneratedField::FixedSizeBinary => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FIXEDSIZEBINARY")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| arrow_type::ArrowTypeEnum::FixedSizeBinary(x.0)); - } - GeneratedField::LargeBinary => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("LARGEBINARY")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeBinary) -; - } - GeneratedField::Date32 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("DATE32")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date32) -; - } - GeneratedField::Date64 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("DATE64")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Date64) -; - } - GeneratedField::Duration => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("DURATION")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option>()?.map(|x| arrow_type::ArrowTypeEnum::Duration(x as i32)); - } - GeneratedField::Timestamp => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("TIMESTAMP")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Timestamp) -; - } - GeneratedField::Time32 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("TIME32")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option>()?.map(|x| arrow_type::ArrowTypeEnum::Time32(x as i32)); - } - GeneratedField::Time64 => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("TIME64")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option>()?.map(|x| arrow_type::ArrowTypeEnum::Time64(x as i32)); - } - GeneratedField::Interval => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("INTERVAL")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option>()?.map(|x| arrow_type::ArrowTypeEnum::Interval(x as i32)); - } - GeneratedField::Decimal => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("DECIMAL")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Decimal) -; - } - GeneratedField::List => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("LIST")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::List) -; - } - GeneratedField::LargeList => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("LARGELIST")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::LargeList) -; - } - GeneratedField::FixedSizeList => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FIXEDSIZELIST")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::FixedSizeList) -; - } - GeneratedField::Struct => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("STRUCT")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Struct) -; - } - GeneratedField::Union => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("UNION")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Union) -; - } - GeneratedField::Dictionary => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("DICTIONARY")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Dictionary) -; - } - GeneratedField::Map => { - if arrow_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("MAP")); - } - arrow_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(arrow_type::ArrowTypeEnum::Map) -; - } - } - } - Ok(ArrowType { - arrow_type_enum: arrow_type_enum__, - }) - } - } - deserializer.deserialize_struct("datafusion.ArrowType", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AvroFormat { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("datafusion.AvroFormat", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AvroFormat { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AvroFormat; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AvroFormat") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map.next_key::()?.is_some() { - let _ = map.next_value::()?; - } - Ok(AvroFormat { - }) - } - } - deserializer.deserialize_struct("datafusion.AvroFormat", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for AvroScanExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.base_conf.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.AvroScanExecNode", len)?; - if let Some(v) = self.base_conf.as_ref() { - struct_ser.serialize_field("baseConf", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for AvroScanExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "base_conf", - "baseConf", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - BaseConf, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = AvroScanExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.AvroScanExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut base_conf__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::BaseConf => { - if base_conf__.is_some() { - return Err(serde::de::Error::duplicate_field("baseConf")); - } - base_conf__ = map.next_value()?; - } - } - } - Ok(AvroScanExecNode { - base_conf: base_conf__, - }) - } - } - deserializer.deserialize_struct("datafusion.AvroScanExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for BareTableReference { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.table.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.BareTableReference", len)?; - if !self.table.is_empty() { - struct_ser.serialize_field("table", &self.table)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for BareTableReference { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "table", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Table, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "table" => Ok(GeneratedField::Table), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = BareTableReference; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.BareTableReference") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut table__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Table => { - if table__.is_some() { - return Err(serde::de::Error::duplicate_field("table")); - } - table__ = Some(map.next_value()?); - } - } - } - Ok(BareTableReference { - table: table__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.BareTableReference", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for BetweenNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.negated { - len += 1; - } - if self.low.is_some() { - len += 1; - } - if self.high.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.BetweenNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - if let Some(v) = self.low.as_ref() { - struct_ser.serialize_field("low", v)?; - } - if let Some(v) = self.high.as_ref() { - struct_ser.serialize_field("high", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for BetweenNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "negated", - "low", - "high", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - Negated, - Low, - High, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "negated" => Ok(GeneratedField::Negated), - "low" => Ok(GeneratedField::Low), - "high" => Ok(GeneratedField::High), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = BetweenNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.BetweenNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut negated__ = None; - let mut low__ = None; - let mut high__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); - } - negated__ = Some(map.next_value()?); - } - GeneratedField::Low => { - if low__.is_some() { - return Err(serde::de::Error::duplicate_field("low")); - } - low__ = map.next_value()?; - } - GeneratedField::High => { - if high__.is_some() { - return Err(serde::de::Error::duplicate_field("high")); - } - high__ = map.next_value()?; - } - } - } - Ok(BetweenNode { - expr: expr__, - negated: negated__.unwrap_or_default(), - low: low__, - high: high__, - }) - } - } - deserializer.deserialize_struct("datafusion.BetweenNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for BinaryExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.operands.is_empty() { - len += 1; - } - if !self.op.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.BinaryExprNode", len)?; - if !self.operands.is_empty() { - struct_ser.serialize_field("operands", &self.operands)?; - } - if !self.op.is_empty() { - struct_ser.serialize_field("op", &self.op)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for BinaryExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "operands", - "op", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Operands, - Op, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "operands" => Ok(GeneratedField::Operands), - "op" => Ok(GeneratedField::Op), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = BinaryExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.BinaryExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut operands__ = None; - let mut op__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Operands => { - if operands__.is_some() { - return Err(serde::de::Error::duplicate_field("operands")); - } - operands__ = Some(map.next_value()?); - } - GeneratedField::Op => { - if op__.is_some() { - return Err(serde::de::Error::duplicate_field("op")); - } - op__ = Some(map.next_value()?); - } - } - } - Ok(BinaryExprNode { - operands: operands__.unwrap_or_default(), - op: op__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.BinaryExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for BuiltInWindowFunction { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::RowNumber => "ROW_NUMBER", - Self::Rank => "RANK", - Self::DenseRank => "DENSE_RANK", - Self::PercentRank => "PERCENT_RANK", - Self::CumeDist => "CUME_DIST", - Self::Ntile => "NTILE", - Self::Lag => "LAG", - Self::Lead => "LEAD", - Self::FirstValue => "FIRST_VALUE", - Self::LastValue => "LAST_VALUE", - Self::NthValue => "NTH_VALUE", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for BuiltInWindowFunction { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "ROW_NUMBER", - "RANK", - "DENSE_RANK", - "PERCENT_RANK", - "CUME_DIST", - "NTILE", - "LAG", - "LEAD", - "FIRST_VALUE", - "LAST_VALUE", - "NTH_VALUE", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = BuiltInWindowFunction; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(BuiltInWindowFunction::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(BuiltInWindowFunction::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "ROW_NUMBER" => Ok(BuiltInWindowFunction::RowNumber), - "RANK" => Ok(BuiltInWindowFunction::Rank), - "DENSE_RANK" => Ok(BuiltInWindowFunction::DenseRank), - "PERCENT_RANK" => Ok(BuiltInWindowFunction::PercentRank), - "CUME_DIST" => Ok(BuiltInWindowFunction::CumeDist), - "NTILE" => Ok(BuiltInWindowFunction::Ntile), - "LAG" => Ok(BuiltInWindowFunction::Lag), - "LEAD" => Ok(BuiltInWindowFunction::Lead), - "FIRST_VALUE" => Ok(BuiltInWindowFunction::FirstValue), - "LAST_VALUE" => Ok(BuiltInWindowFunction::LastValue), - "NTH_VALUE" => Ok(BuiltInWindowFunction::NthValue), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for CaseNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if !self.when_then_expr.is_empty() { - len += 1; - } - if self.else_expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CaseNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if !self.when_then_expr.is_empty() { - struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?; - } - if let Some(v) = self.else_expr.as_ref() { - struct_ser.serialize_field("elseExpr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CaseNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "when_then_expr", - "whenThenExpr", - "else_expr", - "elseExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - WhenThenExpr, - ElseExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr), - "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CaseNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CaseNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut when_then_expr__ = None; - let mut else_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::WhenThenExpr => { - if when_then_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("whenThenExpr")); - } - when_then_expr__ = Some(map.next_value()?); - } - GeneratedField::ElseExpr => { - if else_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("elseExpr")); - } - else_expr__ = map.next_value()?; - } - } - } - Ok(CaseNode { - expr: expr__, - when_then_expr: when_then_expr__.unwrap_or_default(), - else_expr: else_expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.CaseNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CastNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.arrow_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CastNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.arrow_type.as_ref() { - struct_ser.serialize_field("arrowType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CastNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "arrow_type", - "arrowType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - ArrowType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CastNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CastNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut arrow_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::ArrowType => { - if arrow_type__.is_some() { - return Err(serde::de::Error::duplicate_field("arrowType")); - } - arrow_type__ = map.next_value()?; - } - } - } - Ok(CastNode { - expr: expr__, - arrow_type: arrow_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.CastNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CoalesceBatchesExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.target_batch_size != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CoalesceBatchesExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.target_batch_size != 0 { - struct_ser.serialize_field("targetBatchSize", &self.target_batch_size)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CoalesceBatchesExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "target_batch_size", - "targetBatchSize", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - TargetBatchSize, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "targetBatchSize" | "target_batch_size" => Ok(GeneratedField::TargetBatchSize), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CoalesceBatchesExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CoalesceBatchesExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut target_batch_size__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::TargetBatchSize => { - if target_batch_size__.is_some() { - return Err(serde::de::Error::duplicate_field("targetBatchSize")); - } - target_batch_size__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(CoalesceBatchesExecNode { - input: input__, - target_batch_size: target_batch_size__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.CoalesceBatchesExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CoalescePartitionsExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CoalescePartitionsExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CoalescePartitionsExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CoalescePartitionsExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CoalescePartitionsExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - } - } - Ok(CoalescePartitionsExecNode { - input: input__, - }) - } - } - deserializer.deserialize_struct("datafusion.CoalescePartitionsExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Column { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.relation.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Column", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if let Some(v) = self.relation.as_ref() { - struct_ser.serialize_field("relation", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Column { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "relation", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - Relation, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "relation" => Ok(GeneratedField::Relation), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Column; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Column") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut relation__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::Relation => { - if relation__.is_some() { - return Err(serde::de::Error::duplicate_field("relation")); - } - relation__ = map.next_value()?; - } - } - } - Ok(Column { - name: name__.unwrap_or_default(), - relation: relation__, - }) - } - } - deserializer.deserialize_struct("datafusion.Column", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ColumnIndex { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.index != 0 { - len += 1; - } - if self.side != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ColumnIndex", len)?; - if self.index != 0 { - struct_ser.serialize_field("index", &self.index)?; - } - if self.side != 0 { - let v = JoinSide::from_i32(self.side) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.side)))?; - struct_ser.serialize_field("side", &v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ColumnIndex { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "index", - "side", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Index, - Side, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "index" => Ok(GeneratedField::Index), - "side" => Ok(GeneratedField::Side), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ColumnIndex; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ColumnIndex") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut index__ = None; - let mut side__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Index => { - if index__.is_some() { - return Err(serde::de::Error::duplicate_field("index")); - } - index__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Side => { - if side__.is_some() { - return Err(serde::de::Error::duplicate_field("side")); - } - side__ = Some(map.next_value::()? as i32); - } - } - } - Ok(ColumnIndex { - index: index__.unwrap_or_default(), - side: side__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ColumnIndex", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ColumnRelation { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.relation.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ColumnRelation", len)?; - if !self.relation.is_empty() { - struct_ser.serialize_field("relation", &self.relation)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ColumnRelation { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "relation", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Relation, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "relation" => Ok(GeneratedField::Relation), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ColumnRelation; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ColumnRelation") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut relation__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Relation => { - if relation__.is_some() { - return Err(serde::de::Error::duplicate_field("relation")); - } - relation__ = Some(map.next_value()?); - } - } - } - Ok(ColumnRelation { - relation: relation__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ColumnRelation", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ColumnStats { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.min_value.is_some() { - len += 1; - } - if self.max_value.is_some() { - len += 1; - } - if self.null_count != 0 { - len += 1; - } - if self.distinct_count != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ColumnStats", len)?; - if let Some(v) = self.min_value.as_ref() { - struct_ser.serialize_field("minValue", v)?; - } - if let Some(v) = self.max_value.as_ref() { - struct_ser.serialize_field("maxValue", v)?; - } - if self.null_count != 0 { - struct_ser.serialize_field("nullCount", &self.null_count)?; - } - if self.distinct_count != 0 { - struct_ser.serialize_field("distinctCount", &self.distinct_count)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ColumnStats { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "min_value", - "minValue", - "max_value", - "maxValue", - "null_count", - "nullCount", - "distinct_count", - "distinctCount", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - MinValue, - MaxValue, - NullCount, - DistinctCount, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "minValue" | "min_value" => Ok(GeneratedField::MinValue), - "maxValue" | "max_value" => Ok(GeneratedField::MaxValue), - "nullCount" | "null_count" => Ok(GeneratedField::NullCount), - "distinctCount" | "distinct_count" => Ok(GeneratedField::DistinctCount), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ColumnStats; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ColumnStats") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut min_value__ = None; - let mut max_value__ = None; - let mut null_count__ = None; - let mut distinct_count__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::MinValue => { - if min_value__.is_some() { - return Err(serde::de::Error::duplicate_field("minValue")); - } - min_value__ = map.next_value()?; - } - GeneratedField::MaxValue => { - if max_value__.is_some() { - return Err(serde::de::Error::duplicate_field("maxValue")); - } - max_value__ = map.next_value()?; - } - GeneratedField::NullCount => { - if null_count__.is_some() { - return Err(serde::de::Error::duplicate_field("nullCount")); - } - null_count__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::DistinctCount => { - if distinct_count__.is_some() { - return Err(serde::de::Error::duplicate_field("distinctCount")); - } - distinct_count__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(ColumnStats { - min_value: min_value__, - max_value: max_value__, - null_count: null_count__.unwrap_or_default(), - distinct_count: distinct_count__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ColumnStats", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CreateCatalogNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.catalog_name.is_empty() { - len += 1; - } - if self.if_not_exists { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogNode", len)?; - if !self.catalog_name.is_empty() { - struct_ser.serialize_field("catalogName", &self.catalog_name)?; - } - if self.if_not_exists { - struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CreateCatalogNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "catalog_name", - "catalogName", - "if_not_exists", - "ifNotExists", - "schema", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - CatalogName, - IfNotExists, - Schema, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName), - "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists), - "schema" => Ok(GeneratedField::Schema), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateCatalogNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateCatalogNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut catalog_name__ = None; - let mut if_not_exists__ = None; - let mut schema__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::CatalogName => { - if catalog_name__.is_some() { - return Err(serde::de::Error::duplicate_field("catalogName")); - } - catalog_name__ = Some(map.next_value()?); - } - GeneratedField::IfNotExists => { - if if_not_exists__.is_some() { - return Err(serde::de::Error::duplicate_field("ifNotExists")); - } - if_not_exists__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - } - } - Ok(CreateCatalogNode { - catalog_name: catalog_name__.unwrap_or_default(), - if_not_exists: if_not_exists__.unwrap_or_default(), - schema: schema__, - }) - } - } - deserializer.deserialize_struct("datafusion.CreateCatalogNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CreateCatalogSchemaNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.schema_name.is_empty() { - len += 1; - } - if self.if_not_exists { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateCatalogSchemaNode", len)?; - if !self.schema_name.is_empty() { - struct_ser.serialize_field("schemaName", &self.schema_name)?; - } - if self.if_not_exists { - struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CreateCatalogSchemaNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "schema_name", - "schemaName", - "if_not_exists", - "ifNotExists", - "schema", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - SchemaName, - IfNotExists, - Schema, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "schemaName" | "schema_name" => Ok(GeneratedField::SchemaName), - "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists), - "schema" => Ok(GeneratedField::Schema), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateCatalogSchemaNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateCatalogSchemaNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut schema_name__ = None; - let mut if_not_exists__ = None; - let mut schema__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::SchemaName => { - if schema_name__.is_some() { - return Err(serde::de::Error::duplicate_field("schemaName")); - } - schema_name__ = Some(map.next_value()?); - } - GeneratedField::IfNotExists => { - if if_not_exists__.is_some() { - return Err(serde::de::Error::duplicate_field("ifNotExists")); - } - if_not_exists__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - } - } - Ok(CreateCatalogSchemaNode { - schema_name: schema_name__.unwrap_or_default(), - if_not_exists: if_not_exists__.unwrap_or_default(), - schema: schema__, - }) - } - } - deserializer.deserialize_struct("datafusion.CreateCatalogSchemaNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CreateExternalTableNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.name.is_some() { - len += 1; - } - if !self.location.is_empty() { - len += 1; - } - if !self.file_type.is_empty() { - len += 1; - } - if self.has_header { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if !self.table_partition_cols.is_empty() { - len += 1; - } - if self.if_not_exists { - len += 1; - } - if !self.delimiter.is_empty() { - len += 1; - } - if !self.definition.is_empty() { - len += 1; - } - if !self.file_compression_type.is_empty() { - len += 1; - } - if !self.order_exprs.is_empty() { - len += 1; - } - if self.unbounded { - len += 1; - } - if !self.options.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateExternalTableNode", len)?; - if let Some(v) = self.name.as_ref() { - struct_ser.serialize_field("name", v)?; - } - if !self.location.is_empty() { - struct_ser.serialize_field("location", &self.location)?; - } - if !self.file_type.is_empty() { - struct_ser.serialize_field("fileType", &self.file_type)?; - } - if self.has_header { - struct_ser.serialize_field("hasHeader", &self.has_header)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.table_partition_cols.is_empty() { - struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; - } - if self.if_not_exists { - struct_ser.serialize_field("ifNotExists", &self.if_not_exists)?; - } - if !self.delimiter.is_empty() { - struct_ser.serialize_field("delimiter", &self.delimiter)?; - } - if !self.definition.is_empty() { - struct_ser.serialize_field("definition", &self.definition)?; - } - if !self.file_compression_type.is_empty() { - struct_ser.serialize_field("fileCompressionType", &self.file_compression_type)?; - } - if !self.order_exprs.is_empty() { - struct_ser.serialize_field("orderExprs", &self.order_exprs)?; - } - if self.unbounded { - struct_ser.serialize_field("unbounded", &self.unbounded)?; - } - if !self.options.is_empty() { - struct_ser.serialize_field("options", &self.options)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CreateExternalTableNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "location", - "file_type", - "fileType", - "has_header", - "hasHeader", - "schema", - "table_partition_cols", - "tablePartitionCols", - "if_not_exists", - "ifNotExists", - "delimiter", - "definition", - "file_compression_type", - "fileCompressionType", - "order_exprs", - "orderExprs", - "unbounded", - "options", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - Location, - FileType, - HasHeader, - Schema, - TablePartitionCols, - IfNotExists, - Delimiter, - Definition, - FileCompressionType, - OrderExprs, - Unbounded, - Options, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "location" => Ok(GeneratedField::Location), - "fileType" | "file_type" => Ok(GeneratedField::FileType), - "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader), - "schema" => Ok(GeneratedField::Schema), - "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), - "ifNotExists" | "if_not_exists" => Ok(GeneratedField::IfNotExists), - "delimiter" => Ok(GeneratedField::Delimiter), - "definition" => Ok(GeneratedField::Definition), - "fileCompressionType" | "file_compression_type" => Ok(GeneratedField::FileCompressionType), - "orderExprs" | "order_exprs" => Ok(GeneratedField::OrderExprs), - "unbounded" => Ok(GeneratedField::Unbounded), - "options" => Ok(GeneratedField::Options), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateExternalTableNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateExternalTableNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut location__ = None; - let mut file_type__ = None; - let mut has_header__ = None; - let mut schema__ = None; - let mut table_partition_cols__ = None; - let mut if_not_exists__ = None; - let mut delimiter__ = None; - let mut definition__ = None; - let mut file_compression_type__ = None; - let mut order_exprs__ = None; - let mut unbounded__ = None; - let mut options__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = map.next_value()?; - } - GeneratedField::Location => { - if location__.is_some() { - return Err(serde::de::Error::duplicate_field("location")); - } - location__ = Some(map.next_value()?); - } - GeneratedField::FileType => { - if file_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fileType")); - } - file_type__ = Some(map.next_value()?); - } - GeneratedField::HasHeader => { - if has_header__.is_some() { - return Err(serde::de::Error::duplicate_field("hasHeader")); - } - has_header__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::TablePartitionCols => { - if table_partition_cols__.is_some() { - return Err(serde::de::Error::duplicate_field("tablePartitionCols")); - } - table_partition_cols__ = Some(map.next_value()?); - } - GeneratedField::IfNotExists => { - if if_not_exists__.is_some() { - return Err(serde::de::Error::duplicate_field("ifNotExists")); - } - if_not_exists__ = Some(map.next_value()?); - } - GeneratedField::Delimiter => { - if delimiter__.is_some() { - return Err(serde::de::Error::duplicate_field("delimiter")); - } - delimiter__ = Some(map.next_value()?); - } - GeneratedField::Definition => { - if definition__.is_some() { - return Err(serde::de::Error::duplicate_field("definition")); - } - definition__ = Some(map.next_value()?); - } - GeneratedField::FileCompressionType => { - if file_compression_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fileCompressionType")); - } - file_compression_type__ = Some(map.next_value()?); - } - GeneratedField::OrderExprs => { - if order_exprs__.is_some() { - return Err(serde::de::Error::duplicate_field("orderExprs")); - } - order_exprs__ = Some(map.next_value()?); - } - GeneratedField::Unbounded => { - if unbounded__.is_some() { - return Err(serde::de::Error::duplicate_field("unbounded")); - } - unbounded__ = Some(map.next_value()?); - } - GeneratedField::Options => { - if options__.is_some() { - return Err(serde::de::Error::duplicate_field("options")); - } - options__ = Some( - map.next_value::>()? - ); - } - } - } - Ok(CreateExternalTableNode { - name: name__, - location: location__.unwrap_or_default(), - file_type: file_type__.unwrap_or_default(), - has_header: has_header__.unwrap_or_default(), - schema: schema__, - table_partition_cols: table_partition_cols__.unwrap_or_default(), - if_not_exists: if_not_exists__.unwrap_or_default(), - delimiter: delimiter__.unwrap_or_default(), - definition: definition__.unwrap_or_default(), - file_compression_type: file_compression_type__.unwrap_or_default(), - order_exprs: order_exprs__.unwrap_or_default(), - unbounded: unbounded__.unwrap_or_default(), - options: options__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.CreateExternalTableNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CreateViewNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.name.is_some() { - len += 1; - } - if self.input.is_some() { - len += 1; - } - if self.or_replace { - len += 1; - } - if !self.definition.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CreateViewNode", len)?; - if let Some(v) = self.name.as_ref() { - struct_ser.serialize_field("name", v)?; - } - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.or_replace { - struct_ser.serialize_field("orReplace", &self.or_replace)?; - } - if !self.definition.is_empty() { - struct_ser.serialize_field("definition", &self.definition)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CreateViewNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "input", - "or_replace", - "orReplace", - "definition", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - Input, - OrReplace, - Definition, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "input" => Ok(GeneratedField::Input), - "orReplace" | "or_replace" => Ok(GeneratedField::OrReplace), - "definition" => Ok(GeneratedField::Definition), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CreateViewNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CreateViewNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut input__ = None; - let mut or_replace__ = None; - let mut definition__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = map.next_value()?; - } - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::OrReplace => { - if or_replace__.is_some() { - return Err(serde::de::Error::duplicate_field("orReplace")); - } - or_replace__ = Some(map.next_value()?); - } - GeneratedField::Definition => { - if definition__.is_some() { - return Err(serde::de::Error::duplicate_field("definition")); - } - definition__ = Some(map.next_value()?); - } - } - } - Ok(CreateViewNode { - name: name__, - input: input__, - or_replace: or_replace__.unwrap_or_default(), - definition: definition__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.CreateViewNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CrossJoinExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.left.is_some() { - len += 1; - } - if self.right.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinExecNode", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; - } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CrossJoinExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "left", - "right", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Left, - Right, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CrossJoinExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CrossJoinExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut left__ = None; - let mut right__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); - } - left__ = map.next_value()?; - } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); - } - right__ = map.next_value()?; - } - } - } - Ok(CrossJoinExecNode { - left: left__, - right: right__, - }) - } - } - deserializer.deserialize_struct("datafusion.CrossJoinExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CrossJoinNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.left.is_some() { - len += 1; - } - if self.right.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CrossJoinNode", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; - } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CrossJoinNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "left", - "right", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Left, - Right, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CrossJoinNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CrossJoinNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut left__ = None; - let mut right__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); - } - left__ = map.next_value()?; - } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); - } - right__ = map.next_value()?; - } - } - } - Ok(CrossJoinNode { - left: left__, - right: right__, - }) - } - } - deserializer.deserialize_struct("datafusion.CrossJoinNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CsvFormat { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.has_header { - len += 1; - } - if !self.delimiter.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CsvFormat", len)?; - if self.has_header { - struct_ser.serialize_field("hasHeader", &self.has_header)?; - } - if !self.delimiter.is_empty() { - struct_ser.serialize_field("delimiter", &self.delimiter)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CsvFormat { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "has_header", - "hasHeader", - "delimiter", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - HasHeader, - Delimiter, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader), - "delimiter" => Ok(GeneratedField::Delimiter), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CsvFormat; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CsvFormat") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut has_header__ = None; - let mut delimiter__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::HasHeader => { - if has_header__.is_some() { - return Err(serde::de::Error::duplicate_field("hasHeader")); - } - has_header__ = Some(map.next_value()?); - } - GeneratedField::Delimiter => { - if delimiter__.is_some() { - return Err(serde::de::Error::duplicate_field("delimiter")); - } - delimiter__ = Some(map.next_value()?); - } - } - } - Ok(CsvFormat { - has_header: has_header__.unwrap_or_default(), - delimiter: delimiter__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.CsvFormat", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CsvScanExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.base_conf.is_some() { - len += 1; - } - if self.has_header { - len += 1; - } - if !self.delimiter.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CsvScanExecNode", len)?; - if let Some(v) = self.base_conf.as_ref() { - struct_ser.serialize_field("baseConf", v)?; - } - if self.has_header { - struct_ser.serialize_field("hasHeader", &self.has_header)?; - } - if !self.delimiter.is_empty() { - struct_ser.serialize_field("delimiter", &self.delimiter)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CsvScanExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "base_conf", - "baseConf", - "has_header", - "hasHeader", - "delimiter", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - BaseConf, - HasHeader, - Delimiter, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf), - "hasHeader" | "has_header" => Ok(GeneratedField::HasHeader), - "delimiter" => Ok(GeneratedField::Delimiter), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CsvScanExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CsvScanExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut base_conf__ = None; - let mut has_header__ = None; - let mut delimiter__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::BaseConf => { - if base_conf__.is_some() { - return Err(serde::de::Error::duplicate_field("baseConf")); - } - base_conf__ = map.next_value()?; - } - GeneratedField::HasHeader => { - if has_header__.is_some() { - return Err(serde::de::Error::duplicate_field("hasHeader")); - } - has_header__ = Some(map.next_value()?); - } - GeneratedField::Delimiter => { - if delimiter__.is_some() { - return Err(serde::de::Error::duplicate_field("delimiter")); - } - delimiter__ = Some(map.next_value()?); - } - } - } - Ok(CsvScanExecNode { - base_conf: base_conf__, - has_header: has_header__.unwrap_or_default(), - delimiter: delimiter__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.CsvScanExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CubeNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CubeNode", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CubeNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CubeNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CubeNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - } - } - Ok(CubeNode { - expr: expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.CubeNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for CustomTableScanNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.table_name.is_some() { - len += 1; - } - if self.projection.is_some() { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if !self.filters.is_empty() { - len += 1; - } - if !self.custom_table_data.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.CustomTableScanNode", len)?; - if let Some(v) = self.table_name.as_ref() { - struct_ser.serialize_field("tableName", v)?; - } - if let Some(v) = self.projection.as_ref() { - struct_ser.serialize_field("projection", v)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.filters.is_empty() { - struct_ser.serialize_field("filters", &self.filters)?; - } - if !self.custom_table_data.is_empty() { - struct_ser.serialize_field("customTableData", pbjson::private::base64::encode(&self.custom_table_data).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for CustomTableScanNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "table_name", - "tableName", - "projection", - "schema", - "filters", - "custom_table_data", - "customTableData", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - TableName, - Projection, - Schema, - Filters, - CustomTableData, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "tableName" | "table_name" => Ok(GeneratedField::TableName), - "projection" => Ok(GeneratedField::Projection), - "schema" => Ok(GeneratedField::Schema), - "filters" => Ok(GeneratedField::Filters), - "customTableData" | "custom_table_data" => Ok(GeneratedField::CustomTableData), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = CustomTableScanNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.CustomTableScanNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut table_name__ = None; - let mut projection__ = None; - let mut schema__ = None; - let mut filters__ = None; - let mut custom_table_data__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::TableName => { - if table_name__.is_some() { - return Err(serde::de::Error::duplicate_field("tableName")); - } - table_name__ = map.next_value()?; - } - GeneratedField::Projection => { - if projection__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - projection__ = map.next_value()?; - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::Filters => { - if filters__.is_some() { - return Err(serde::de::Error::duplicate_field("filters")); - } - filters__ = Some(map.next_value()?); - } - GeneratedField::CustomTableData => { - if custom_table_data__.is_some() { - return Err(serde::de::Error::duplicate_field("customTableData")); - } - custom_table_data__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - } - } - Ok(CustomTableScanNode { - table_name: table_name__, - projection: projection__, - schema: schema__, - filters: filters__.unwrap_or_default(), - custom_table_data: custom_table_data__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.CustomTableScanNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DateUnit { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Day => "Day", - Self::DateMillisecond => "DateMillisecond", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for DateUnit { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "Day", - "DateMillisecond", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DateUnit; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(DateUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(DateUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "Day" => Ok(DateUnit::Day), - "DateMillisecond" => Ok(DateUnit::DateMillisecond), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for Decimal { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.precision != 0 { - len += 1; - } - if self.scale != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Decimal", len)?; - if self.precision != 0 { - struct_ser.serialize_field("precision", &self.precision)?; - } - if self.scale != 0 { - struct_ser.serialize_field("scale", &self.scale)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Decimal { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "precision", - "scale", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Precision, - Scale, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "precision" => Ok(GeneratedField::Precision), - "scale" => Ok(GeneratedField::Scale), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Decimal; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Decimal") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut precision__ = None; - let mut scale__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Precision => { - if precision__.is_some() { - return Err(serde::de::Error::duplicate_field("precision")); - } - precision__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Scale => { - if scale__.is_some() { - return Err(serde::de::Error::duplicate_field("scale")); - } - scale__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(Decimal { - precision: precision__.unwrap_or_default(), - scale: scale__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Decimal", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Decimal128 { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.value.is_empty() { - len += 1; - } - if self.p != 0 { - len += 1; - } - if self.s != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Decimal128", len)?; - if !self.value.is_empty() { - struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?; - } - if self.p != 0 { - struct_ser.serialize_field("p", ToString::to_string(&self.p).as_str())?; - } - if self.s != 0 { - struct_ser.serialize_field("s", ToString::to_string(&self.s).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Decimal128 { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "value", - "p", - "s", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Value, - P, - S, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "value" => Ok(GeneratedField::Value), - "p" => Ok(GeneratedField::P), - "s" => Ok(GeneratedField::S), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Decimal128; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Decimal128") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut value__ = None; - let mut p__ = None; - let mut s__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); - } - value__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::P => { - if p__.is_some() { - return Err(serde::de::Error::duplicate_field("p")); - } - p__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::S => { - if s__.is_some() { - return Err(serde::de::Error::duplicate_field("s")); - } - s__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(Decimal128 { - value: value__.unwrap_or_default(), - p: p__.unwrap_or_default(), - s: s__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Decimal128", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DfField { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.field.is_some() { - len += 1; - } - if self.qualifier.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.DfField", len)?; - if let Some(v) = self.field.as_ref() { - struct_ser.serialize_field("field", v)?; - } - if let Some(v) = self.qualifier.as_ref() { - struct_ser.serialize_field("qualifier", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for DfField { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "field", - "qualifier", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Field, - Qualifier, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "field" => Ok(GeneratedField::Field), - "qualifier" => Ok(GeneratedField::Qualifier), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DfField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.DfField") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut field__ = None; - let mut qualifier__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Field => { - if field__.is_some() { - return Err(serde::de::Error::duplicate_field("field")); - } - field__ = map.next_value()?; - } - GeneratedField::Qualifier => { - if qualifier__.is_some() { - return Err(serde::de::Error::duplicate_field("qualifier")); - } - qualifier__ = map.next_value()?; - } - } - } - Ok(DfField { - field: field__, - qualifier: qualifier__, - }) - } - } - deserializer.deserialize_struct("datafusion.DfField", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DfSchema { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.columns.is_empty() { - len += 1; - } - if !self.metadata.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.DfSchema", len)?; - if !self.columns.is_empty() { - struct_ser.serialize_field("columns", &self.columns)?; - } - if !self.metadata.is_empty() { - struct_ser.serialize_field("metadata", &self.metadata)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for DfSchema { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "columns", - "metadata", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Columns, - Metadata, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "columns" => Ok(GeneratedField::Columns), - "metadata" => Ok(GeneratedField::Metadata), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DfSchema; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.DfSchema") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut columns__ = None; - let mut metadata__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Columns => { - if columns__.is_some() { - return Err(serde::de::Error::duplicate_field("columns")); - } - columns__ = Some(map.next_value()?); - } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); - } - metadata__ = Some( - map.next_value::>()? - ); - } - } - } - Ok(DfSchema { - columns: columns__.unwrap_or_default(), - metadata: metadata__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.DfSchema", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Dictionary { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.key.is_some() { - len += 1; - } - if self.value.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Dictionary", len)?; - if let Some(v) = self.key.as_ref() { - struct_ser.serialize_field("key", v)?; - } - if let Some(v) = self.value.as_ref() { - struct_ser.serialize_field("value", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Dictionary { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "key", - "value", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Key, - Value, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "key" => Ok(GeneratedField::Key), - "value" => Ok(GeneratedField::Value), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Dictionary; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Dictionary") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut key__ = None; - let mut value__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); - } - key__ = map.next_value()?; - } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); - } - value__ = map.next_value()?; - } - } - } - Ok(Dictionary { - key: key__, - value: value__, - }) - } - } - deserializer.deserialize_struct("datafusion.Dictionary", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DistinctNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.DistinctNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for DistinctNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DistinctNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.DistinctNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - } - } - Ok(DistinctNode { - input: input__, - }) - } - } - deserializer.deserialize_struct("datafusion.DistinctNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for DropViewNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.name.is_some() { - len += 1; - } - if self.if_exists { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.DropViewNode", len)?; - if let Some(v) = self.name.as_ref() { - struct_ser.serialize_field("name", v)?; - } - if self.if_exists { - struct_ser.serialize_field("ifExists", &self.if_exists)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for DropViewNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "if_exists", - "ifExists", - "schema", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - IfExists, - Schema, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "ifExists" | "if_exists" => Ok(GeneratedField::IfExists), - "schema" => Ok(GeneratedField::Schema), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = DropViewNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.DropViewNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut if_exists__ = None; - let mut schema__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = map.next_value()?; - } - GeneratedField::IfExists => { - if if_exists__.is_some() { - return Err(serde::de::Error::duplicate_field("ifExists")); - } - if_exists__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - } - } - Ok(DropViewNode { - name: name__, - if_exists: if_exists__.unwrap_or_default(), - schema: schema__, - }) - } - } - deserializer.deserialize_struct("datafusion.DropViewNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for EmptyExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.produce_one_row { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.EmptyExecNode", len)?; - if self.produce_one_row { - struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for EmptyExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "produce_one_row", - "produceOneRow", - "schema", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - ProduceOneRow, - Schema, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow), - "schema" => Ok(GeneratedField::Schema), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = EmptyExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.EmptyExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut produce_one_row__ = None; - let mut schema__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::ProduceOneRow => { - if produce_one_row__.is_some() { - return Err(serde::de::Error::duplicate_field("produceOneRow")); - } - produce_one_row__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - } - } - Ok(EmptyExecNode { - produce_one_row: produce_one_row__.unwrap_or_default(), - schema: schema__, - }) - } - } - deserializer.deserialize_struct("datafusion.EmptyExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for EmptyMessage { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("datafusion.EmptyMessage", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for EmptyMessage { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = EmptyMessage; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.EmptyMessage") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map.next_key::()?.is_some() { - let _ = map.next_value::()?; - } - Ok(EmptyMessage { - }) - } - } - deserializer.deserialize_struct("datafusion.EmptyMessage", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for EmptyRelationNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.produce_one_row { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.EmptyRelationNode", len)?; - if self.produce_one_row { - struct_ser.serialize_field("produceOneRow", &self.produce_one_row)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for EmptyRelationNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "produce_one_row", - "produceOneRow", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - ProduceOneRow, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "produceOneRow" | "produce_one_row" => Ok(GeneratedField::ProduceOneRow), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = EmptyRelationNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.EmptyRelationNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut produce_one_row__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::ProduceOneRow => { - if produce_one_row__.is_some() { - return Err(serde::de::Error::duplicate_field("produceOneRow")); - } - produce_one_row__ = Some(map.next_value()?); - } - } - } - Ok(EmptyRelationNode { - produce_one_row: produce_one_row__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.EmptyRelationNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ExplainExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.schema.is_some() { - len += 1; - } - if !self.stringified_plans.is_empty() { - len += 1; - } - if self.verbose { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ExplainExecNode", len)?; - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.stringified_plans.is_empty() { - struct_ser.serialize_field("stringifiedPlans", &self.stringified_plans)?; - } - if self.verbose { - struct_ser.serialize_field("verbose", &self.verbose)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ExplainExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "schema", - "stringified_plans", - "stringifiedPlans", - "verbose", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Schema, - StringifiedPlans, - Verbose, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "schema" => Ok(GeneratedField::Schema), - "stringifiedPlans" | "stringified_plans" => Ok(GeneratedField::StringifiedPlans), - "verbose" => Ok(GeneratedField::Verbose), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExplainExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ExplainExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut schema__ = None; - let mut stringified_plans__ = None; - let mut verbose__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::StringifiedPlans => { - if stringified_plans__.is_some() { - return Err(serde::de::Error::duplicate_field("stringifiedPlans")); - } - stringified_plans__ = Some(map.next_value()?); - } - GeneratedField::Verbose => { - if verbose__.is_some() { - return Err(serde::de::Error::duplicate_field("verbose")); - } - verbose__ = Some(map.next_value()?); - } - } - } - Ok(ExplainExecNode { - schema: schema__, - stringified_plans: stringified_plans__.unwrap_or_default(), - verbose: verbose__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ExplainExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ExplainNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.verbose { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ExplainNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.verbose { - struct_ser.serialize_field("verbose", &self.verbose)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ExplainNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "verbose", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Verbose, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "verbose" => Ok(GeneratedField::Verbose), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ExplainNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ExplainNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut verbose__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Verbose => { - if verbose__.is_some() { - return Err(serde::de::Error::duplicate_field("verbose")); - } - verbose__ = Some(map.next_value()?); - } - } - } - Ok(ExplainNode { - input: input__, - verbose: verbose__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ExplainNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Field { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.arrow_type.is_some() { - len += 1; - } - if self.nullable { - len += 1; - } - if !self.children.is_empty() { - len += 1; - } - if !self.metadata.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Field", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if let Some(v) = self.arrow_type.as_ref() { - struct_ser.serialize_field("arrowType", v)?; - } - if self.nullable { - struct_ser.serialize_field("nullable", &self.nullable)?; - } - if !self.children.is_empty() { - struct_ser.serialize_field("children", &self.children)?; - } - if !self.metadata.is_empty() { - struct_ser.serialize_field("metadata", &self.metadata)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Field { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "arrow_type", - "arrowType", - "nullable", - "children", - "metadata", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - ArrowType, - Nullable, - Children, - Metadata, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), - "nullable" => Ok(GeneratedField::Nullable), - "children" => Ok(GeneratedField::Children), - "metadata" => Ok(GeneratedField::Metadata), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Field; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Field") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut arrow_type__ = None; - let mut nullable__ = None; - let mut children__ = None; - let mut metadata__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::ArrowType => { - if arrow_type__.is_some() { - return Err(serde::de::Error::duplicate_field("arrowType")); - } - arrow_type__ = map.next_value()?; - } - GeneratedField::Nullable => { - if nullable__.is_some() { - return Err(serde::de::Error::duplicate_field("nullable")); - } - nullable__ = Some(map.next_value()?); - } - GeneratedField::Children => { - if children__.is_some() { - return Err(serde::de::Error::duplicate_field("children")); - } - children__ = Some(map.next_value()?); - } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); - } - metadata__ = Some( - map.next_value::>()? - ); - } - } - } - Ok(Field { - name: name__.unwrap_or_default(), - arrow_type: arrow_type__, - nullable: nullable__.unwrap_or_default(), - children: children__.unwrap_or_default(), - metadata: metadata__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Field", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for FileGroup { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.files.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.FileGroup", len)?; - if !self.files.is_empty() { - struct_ser.serialize_field("files", &self.files)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for FileGroup { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "files", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Files, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "files" => Ok(GeneratedField::Files), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FileGroup; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FileGroup") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut files__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Files => { - if files__.is_some() { - return Err(serde::de::Error::duplicate_field("files")); - } - files__ = Some(map.next_value()?); - } - } - } - Ok(FileGroup { - files: files__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.FileGroup", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for FileRange { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.start != 0 { - len += 1; - } - if self.end != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.FileRange", len)?; - if self.start != 0 { - struct_ser.serialize_field("start", ToString::to_string(&self.start).as_str())?; - } - if self.end != 0 { - struct_ser.serialize_field("end", ToString::to_string(&self.end).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for FileRange { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "start", - "end", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Start, - End, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "start" => Ok(GeneratedField::Start), - "end" => Ok(GeneratedField::End), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FileRange; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FileRange") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut start__ = None; - let mut end__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Start => { - if start__.is_some() { - return Err(serde::de::Error::duplicate_field("start")); - } - start__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::End => { - if end__.is_some() { - return Err(serde::de::Error::duplicate_field("end")); - } - end__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(FileRange { - start: start__.unwrap_or_default(), - end: end__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.FileRange", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for FileScanExecConf { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.file_groups.is_empty() { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if !self.projection.is_empty() { - len += 1; - } - if self.limit.is_some() { - len += 1; - } - if self.statistics.is_some() { - len += 1; - } - if !self.table_partition_cols.is_empty() { - len += 1; - } - if !self.object_store_url.is_empty() { - len += 1; - } - if !self.output_ordering.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.FileScanExecConf", len)?; - if !self.file_groups.is_empty() { - struct_ser.serialize_field("fileGroups", &self.file_groups)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.projection.is_empty() { - struct_ser.serialize_field("projection", &self.projection)?; - } - if let Some(v) = self.limit.as_ref() { - struct_ser.serialize_field("limit", v)?; - } - if let Some(v) = self.statistics.as_ref() { - struct_ser.serialize_field("statistics", v)?; - } - if !self.table_partition_cols.is_empty() { - struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; - } - if !self.object_store_url.is_empty() { - struct_ser.serialize_field("objectStoreUrl", &self.object_store_url)?; - } - if !self.output_ordering.is_empty() { - struct_ser.serialize_field("outputOrdering", &self.output_ordering)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for FileScanExecConf { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "file_groups", - "fileGroups", - "schema", - "projection", - "limit", - "statistics", - "table_partition_cols", - "tablePartitionCols", - "object_store_url", - "objectStoreUrl", - "output_ordering", - "outputOrdering", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - FileGroups, - Schema, - Projection, - Limit, - Statistics, - TablePartitionCols, - ObjectStoreUrl, - OutputOrdering, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "fileGroups" | "file_groups" => Ok(GeneratedField::FileGroups), - "schema" => Ok(GeneratedField::Schema), - "projection" => Ok(GeneratedField::Projection), - "limit" => Ok(GeneratedField::Limit), - "statistics" => Ok(GeneratedField::Statistics), - "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), - "objectStoreUrl" | "object_store_url" => Ok(GeneratedField::ObjectStoreUrl), - "outputOrdering" | "output_ordering" => Ok(GeneratedField::OutputOrdering), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FileScanExecConf; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FileScanExecConf") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut file_groups__ = None; - let mut schema__ = None; - let mut projection__ = None; - let mut limit__ = None; - let mut statistics__ = None; - let mut table_partition_cols__ = None; - let mut object_store_url__ = None; - let mut output_ordering__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::FileGroups => { - if file_groups__.is_some() { - return Err(serde::de::Error::duplicate_field("fileGroups")); - } - file_groups__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::Projection => { - if projection__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - projection__ = - Some(map.next_value::>>()? - .into_iter().map(|x| x.0).collect()) - ; - } - GeneratedField::Limit => { - if limit__.is_some() { - return Err(serde::de::Error::duplicate_field("limit")); - } - limit__ = map.next_value()?; - } - GeneratedField::Statistics => { - if statistics__.is_some() { - return Err(serde::de::Error::duplicate_field("statistics")); - } - statistics__ = map.next_value()?; - } - GeneratedField::TablePartitionCols => { - if table_partition_cols__.is_some() { - return Err(serde::de::Error::duplicate_field("tablePartitionCols")); - } - table_partition_cols__ = Some(map.next_value()?); - } - GeneratedField::ObjectStoreUrl => { - if object_store_url__.is_some() { - return Err(serde::de::Error::duplicate_field("objectStoreUrl")); - } - object_store_url__ = Some(map.next_value()?); - } - GeneratedField::OutputOrdering => { - if output_ordering__.is_some() { - return Err(serde::de::Error::duplicate_field("outputOrdering")); - } - output_ordering__ = Some(map.next_value()?); - } - } - } - Ok(FileScanExecConf { - file_groups: file_groups__.unwrap_or_default(), - schema: schema__, - projection: projection__.unwrap_or_default(), - limit: limit__, - statistics: statistics__, - table_partition_cols: table_partition_cols__.unwrap_or_default(), - object_store_url: object_store_url__.unwrap_or_default(), - output_ordering: output_ordering__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.FileScanExecConf", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for FilterExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.FilterExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for FilterExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FilterExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FilterExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(FilterExecNode { - input: input__, - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.FilterExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for FixedSizeBinary { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.length != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeBinary", len)?; - if self.length != 0 { - struct_ser.serialize_field("length", &self.length)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for FixedSizeBinary { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "length", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Length, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "length" => Ok(GeneratedField::Length), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FixedSizeBinary; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FixedSizeBinary") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut length__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Length => { - if length__.is_some() { - return Err(serde::de::Error::duplicate_field("length")); - } - length__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(FixedSizeBinary { - length: length__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.FixedSizeBinary", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for FixedSizeList { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.field_type.is_some() { - len += 1; - } - if self.list_size != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.FixedSizeList", len)?; - if let Some(v) = self.field_type.as_ref() { - struct_ser.serialize_field("fieldType", v)?; - } - if self.list_size != 0 { - struct_ser.serialize_field("listSize", &self.list_size)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for FixedSizeList { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "field_type", - "fieldType", - "list_size", - "listSize", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - FieldType, - ListSize, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "fieldType" | "field_type" => Ok(GeneratedField::FieldType), - "listSize" | "list_size" => Ok(GeneratedField::ListSize), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FixedSizeList; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FixedSizeList") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut field_type__ = None; - let mut list_size__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::FieldType => { - if field_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fieldType")); - } - field_type__ = map.next_value()?; - } - GeneratedField::ListSize => { - if list_size__.is_some() { - return Err(serde::de::Error::duplicate_field("listSize")); - } - list_size__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(FixedSizeList { - field_type: field_type__, - list_size: list_size__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.FixedSizeList", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for FullTableReference { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.catalog.is_empty() { - len += 1; - } - if !self.schema.is_empty() { - len += 1; - } - if !self.table.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.FullTableReference", len)?; - if !self.catalog.is_empty() { - struct_ser.serialize_field("catalog", &self.catalog)?; - } - if !self.schema.is_empty() { - struct_ser.serialize_field("schema", &self.schema)?; - } - if !self.table.is_empty() { - struct_ser.serialize_field("table", &self.table)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for FullTableReference { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "catalog", - "schema", - "table", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Catalog, - Schema, - Table, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "catalog" => Ok(GeneratedField::Catalog), - "schema" => Ok(GeneratedField::Schema), - "table" => Ok(GeneratedField::Table), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = FullTableReference; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.FullTableReference") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut catalog__ = None; - let mut schema__ = None; - let mut table__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Catalog => { - if catalog__.is_some() { - return Err(serde::de::Error::duplicate_field("catalog")); - } - catalog__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = Some(map.next_value()?); - } - GeneratedField::Table => { - if table__.is_some() { - return Err(serde::de::Error::duplicate_field("table")); - } - table__ = Some(map.next_value()?); - } - } - } - Ok(FullTableReference { - catalog: catalog__.unwrap_or_default(), - schema: schema__.unwrap_or_default(), - table: table__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.FullTableReference", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for GetIndexedField { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.key.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.GetIndexedField", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.key.as_ref() { - struct_ser.serialize_field("key", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for GetIndexedField { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "key", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - Key, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "key" => Ok(GeneratedField::Key), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GetIndexedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.GetIndexedField") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut key__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); - } - key__ = map.next_value()?; - } - } - } - Ok(GetIndexedField { - expr: expr__, - key: key__, - }) - } - } - deserializer.deserialize_struct("datafusion.GetIndexedField", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for GlobalLimitExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.skip != 0 { - len += 1; - } - if self.fetch != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.GlobalLimitExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.skip != 0 { - struct_ser.serialize_field("skip", &self.skip)?; - } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for GlobalLimitExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "skip", - "fetch", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Skip, - Fetch, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "skip" => Ok(GeneratedField::Skip), - "fetch" => Ok(GeneratedField::Fetch), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GlobalLimitExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.GlobalLimitExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut skip__ = None; - let mut fetch__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Skip => { - if skip__.is_some() { - return Err(serde::de::Error::duplicate_field("skip")); - } - skip__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); - } - fetch__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(GlobalLimitExecNode { - input: input__, - skip: skip__.unwrap_or_default(), - fetch: fetch__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.GlobalLimitExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for GroupingSetNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.GroupingSetNode", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for GroupingSetNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GroupingSetNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.GroupingSetNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - } - } - Ok(GroupingSetNode { - expr: expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.GroupingSetNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for HashJoinExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.left.is_some() { - len += 1; - } - if self.right.is_some() { - len += 1; - } - if !self.on.is_empty() { - len += 1; - } - if self.join_type != 0 { - len += 1; - } - if self.partition_mode != 0 { - len += 1; - } - if self.null_equals_null { - len += 1; - } - if self.filter.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.HashJoinExecNode", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; - } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; - } - if !self.on.is_empty() { - struct_ser.serialize_field("on", &self.on)?; - } - if self.join_type != 0 { - let v = JoinType::from_i32(self.join_type) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?; - struct_ser.serialize_field("joinType", &v)?; - } - if self.partition_mode != 0 { - let v = PartitionMode::from_i32(self.partition_mode) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.partition_mode)))?; - struct_ser.serialize_field("partitionMode", &v)?; - } - if self.null_equals_null { - struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?; - } - if let Some(v) = self.filter.as_ref() { - struct_ser.serialize_field("filter", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for HashJoinExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "left", - "right", - "on", - "join_type", - "joinType", - "partition_mode", - "partitionMode", - "null_equals_null", - "nullEqualsNull", - "filter", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Left, - Right, - On, - JoinType, - PartitionMode, - NullEqualsNull, - Filter, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), - "on" => Ok(GeneratedField::On), - "joinType" | "join_type" => Ok(GeneratedField::JoinType), - "partitionMode" | "partition_mode" => Ok(GeneratedField::PartitionMode), - "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull), - "filter" => Ok(GeneratedField::Filter), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = HashJoinExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.HashJoinExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut left__ = None; - let mut right__ = None; - let mut on__ = None; - let mut join_type__ = None; - let mut partition_mode__ = None; - let mut null_equals_null__ = None; - let mut filter__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); - } - left__ = map.next_value()?; - } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); - } - right__ = map.next_value()?; - } - GeneratedField::On => { - if on__.is_some() { - return Err(serde::de::Error::duplicate_field("on")); - } - on__ = Some(map.next_value()?); - } - GeneratedField::JoinType => { - if join_type__.is_some() { - return Err(serde::de::Error::duplicate_field("joinType")); - } - join_type__ = Some(map.next_value::()? as i32); - } - GeneratedField::PartitionMode => { - if partition_mode__.is_some() { - return Err(serde::de::Error::duplicate_field("partitionMode")); - } - partition_mode__ = Some(map.next_value::()? as i32); - } - GeneratedField::NullEqualsNull => { - if null_equals_null__.is_some() { - return Err(serde::de::Error::duplicate_field("nullEqualsNull")); - } - null_equals_null__ = Some(map.next_value()?); - } - GeneratedField::Filter => { - if filter__.is_some() { - return Err(serde::de::Error::duplicate_field("filter")); - } - filter__ = map.next_value()?; - } - } - } - Ok(HashJoinExecNode { - left: left__, - right: right__, - on: on__.unwrap_or_default(), - join_type: join_type__.unwrap_or_default(), - partition_mode: partition_mode__.unwrap_or_default(), - null_equals_null: null_equals_null__.unwrap_or_default(), - filter: filter__, - }) - } - } - deserializer.deserialize_struct("datafusion.HashJoinExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for HashRepartition { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.hash_expr.is_empty() { - len += 1; - } - if self.partition_count != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.HashRepartition", len)?; - if !self.hash_expr.is_empty() { - struct_ser.serialize_field("hashExpr", &self.hash_expr)?; - } - if self.partition_count != 0 { - struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for HashRepartition { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "hash_expr", - "hashExpr", - "partition_count", - "partitionCount", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - HashExpr, - PartitionCount, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr), - "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = HashRepartition; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.HashRepartition") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut hash_expr__ = None; - let mut partition_count__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::HashExpr => { - if hash_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("hashExpr")); - } - hash_expr__ = Some(map.next_value()?); - } - GeneratedField::PartitionCount => { - if partition_count__.is_some() { - return Err(serde::de::Error::duplicate_field("partitionCount")); - } - partition_count__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(HashRepartition { - hash_expr: hash_expr__.unwrap_or_default(), - partition_count: partition_count__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.HashRepartition", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ILikeNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.negated { - len += 1; - } - if self.expr.is_some() { - len += 1; - } - if self.pattern.is_some() { - len += 1; - } - if !self.escape_char.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ILikeNode", len)?; - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.pattern.as_ref() { - struct_ser.serialize_field("pattern", v)?; - } - if !self.escape_char.is_empty() { - struct_ser.serialize_field("escapeChar", &self.escape_char)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ILikeNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "negated", - "expr", - "pattern", - "escape_char", - "escapeChar", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Negated, - Expr, - Pattern, - EscapeChar, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "negated" => Ok(GeneratedField::Negated), - "expr" => Ok(GeneratedField::Expr), - "pattern" => Ok(GeneratedField::Pattern), - "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ILikeNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ILikeNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut negated__ = None; - let mut expr__ = None; - let mut pattern__ = None; - let mut escape_char__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); - } - negated__ = Some(map.next_value()?); - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Pattern => { - if pattern__.is_some() { - return Err(serde::de::Error::duplicate_field("pattern")); - } - pattern__ = map.next_value()?; - } - GeneratedField::EscapeChar => { - if escape_char__.is_some() { - return Err(serde::de::Error::duplicate_field("escapeChar")); - } - escape_char__ = Some(map.next_value()?); - } - } - } - Ok(ILikeNode { - negated: negated__.unwrap_or_default(), - expr: expr__, - pattern: pattern__, - escape_char: escape_char__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ILikeNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for InListNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if !self.list.is_empty() { - len += 1; - } - if self.negated { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.InListNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if !self.list.is_empty() { - struct_ser.serialize_field("list", &self.list)?; - } - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for InListNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "list", - "negated", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - List, - Negated, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "list" => Ok(GeneratedField::List), - "negated" => Ok(GeneratedField::Negated), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = InListNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.InListNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut list__ = None; - let mut negated__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::List => { - if list__.is_some() { - return Err(serde::de::Error::duplicate_field("list")); - } - list__ = Some(map.next_value()?); - } - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); - } - negated__ = Some(map.next_value()?); - } - } - } - Ok(InListNode { - expr: expr__, - list: list__.unwrap_or_default(), - negated: negated__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.InListNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IntervalMonthDayNanoValue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.months != 0 { - len += 1; - } - if self.days != 0 { - len += 1; - } - if self.nanos != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IntervalMonthDayNanoValue", len)?; - if self.months != 0 { - struct_ser.serialize_field("months", &self.months)?; - } - if self.days != 0 { - struct_ser.serialize_field("days", &self.days)?; - } - if self.nanos != 0 { - struct_ser.serialize_field("nanos", ToString::to_string(&self.nanos).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IntervalMonthDayNanoValue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "months", - "days", - "nanos", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Months, - Days, - Nanos, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "months" => Ok(GeneratedField::Months), - "days" => Ok(GeneratedField::Days), - "nanos" => Ok(GeneratedField::Nanos), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IntervalMonthDayNanoValue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IntervalMonthDayNanoValue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut months__ = None; - let mut days__ = None; - let mut nanos__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Months => { - if months__.is_some() { - return Err(serde::de::Error::duplicate_field("months")); - } - months__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Days => { - if days__.is_some() { - return Err(serde::de::Error::duplicate_field("days")); - } - days__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Nanos => { - if nanos__.is_some() { - return Err(serde::de::Error::duplicate_field("nanos")); - } - nanos__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(IntervalMonthDayNanoValue { - months: months__.unwrap_or_default(), - days: days__.unwrap_or_default(), - nanos: nanos__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.IntervalMonthDayNanoValue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IntervalUnit { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::YearMonth => "YearMonth", - Self::DayTime => "DayTime", - Self::MonthDayNano => "MonthDayNano", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for IntervalUnit { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "YearMonth", - "DayTime", - "MonthDayNano", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IntervalUnit; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(IntervalUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(IntervalUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "YearMonth" => Ok(IntervalUnit::YearMonth), - "DayTime" => Ok(IntervalUnit::DayTime), - "MonthDayNano" => Ok(IntervalUnit::MonthDayNano), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for IsFalse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsFalse", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsFalse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsFalse; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsFalse") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsFalse { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsFalse", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IsNotFalse { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotFalse", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsNotFalse { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotFalse; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotFalse") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsNotFalse { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsNotFalse", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IsNotNull { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotNull", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsNotNull { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotNull; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotNull") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsNotNull { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsNotNull", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IsNotTrue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotTrue", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsNotTrue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotTrue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotTrue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsNotTrue { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsNotTrue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IsNotUnknown { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNotUnknown", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsNotUnknown { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNotUnknown; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNotUnknown") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsNotUnknown { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsNotUnknown", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IsNull { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsNull", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsNull { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsNull; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsNull") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsNull { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsNull", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IsTrue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsTrue", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsTrue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsTrue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsTrue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsTrue { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsTrue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for IsUnknown { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.IsUnknown", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for IsUnknown { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = IsUnknown; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.IsUnknown") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(IsUnknown { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.IsUnknown", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for JoinConstraint { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::On => "ON", - Self::Using => "USING", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for JoinConstraint { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "ON", - "USING", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinConstraint; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinConstraint::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinConstraint::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "ON" => Ok(JoinConstraint::On), - "USING" => Ok(JoinConstraint::Using), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for JoinFilter { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expression.is_some() { - len += 1; - } - if !self.column_indices.is_empty() { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.JoinFilter", len)?; - if let Some(v) = self.expression.as_ref() { - struct_ser.serialize_field("expression", v)?; - } - if !self.column_indices.is_empty() { - struct_ser.serialize_field("columnIndices", &self.column_indices)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for JoinFilter { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expression", - "column_indices", - "columnIndices", - "schema", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expression, - ColumnIndices, - Schema, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expression" => Ok(GeneratedField::Expression), - "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices), - "schema" => Ok(GeneratedField::Schema), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinFilter; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.JoinFilter") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expression__ = None; - let mut column_indices__ = None; - let mut schema__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expression => { - if expression__.is_some() { - return Err(serde::de::Error::duplicate_field("expression")); - } - expression__ = map.next_value()?; - } - GeneratedField::ColumnIndices => { - if column_indices__.is_some() { - return Err(serde::de::Error::duplicate_field("columnIndices")); - } - column_indices__ = Some(map.next_value()?); - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - } - } - Ok(JoinFilter { - expression: expression__, - column_indices: column_indices__.unwrap_or_default(), - schema: schema__, - }) - } - } - deserializer.deserialize_struct("datafusion.JoinFilter", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for JoinNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.left.is_some() { - len += 1; - } - if self.right.is_some() { - len += 1; - } - if self.join_type != 0 { - len += 1; - } - if self.join_constraint != 0 { - len += 1; - } - if !self.left_join_key.is_empty() { - len += 1; - } - if !self.right_join_key.is_empty() { - len += 1; - } - if self.null_equals_null { - len += 1; - } - if self.filter.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.JoinNode", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; - } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; - } - if self.join_type != 0 { - let v = JoinType::from_i32(self.join_type) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?; - struct_ser.serialize_field("joinType", &v)?; - } - if self.join_constraint != 0 { - let v = JoinConstraint::from_i32(self.join_constraint) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_constraint)))?; - struct_ser.serialize_field("joinConstraint", &v)?; - } - if !self.left_join_key.is_empty() { - struct_ser.serialize_field("leftJoinKey", &self.left_join_key)?; - } - if !self.right_join_key.is_empty() { - struct_ser.serialize_field("rightJoinKey", &self.right_join_key)?; - } - if self.null_equals_null { - struct_ser.serialize_field("nullEqualsNull", &self.null_equals_null)?; - } - if let Some(v) = self.filter.as_ref() { - struct_ser.serialize_field("filter", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for JoinNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "left", - "right", - "join_type", - "joinType", - "join_constraint", - "joinConstraint", - "left_join_key", - "leftJoinKey", - "right_join_key", - "rightJoinKey", - "null_equals_null", - "nullEqualsNull", - "filter", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Left, - Right, - JoinType, - JoinConstraint, - LeftJoinKey, - RightJoinKey, - NullEqualsNull, - Filter, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), - "joinType" | "join_type" => Ok(GeneratedField::JoinType), - "joinConstraint" | "join_constraint" => Ok(GeneratedField::JoinConstraint), - "leftJoinKey" | "left_join_key" => Ok(GeneratedField::LeftJoinKey), - "rightJoinKey" | "right_join_key" => Ok(GeneratedField::RightJoinKey), - "nullEqualsNull" | "null_equals_null" => Ok(GeneratedField::NullEqualsNull), - "filter" => Ok(GeneratedField::Filter), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.JoinNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut left__ = None; - let mut right__ = None; - let mut join_type__ = None; - let mut join_constraint__ = None; - let mut left_join_key__ = None; - let mut right_join_key__ = None; - let mut null_equals_null__ = None; - let mut filter__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); - } - left__ = map.next_value()?; - } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); - } - right__ = map.next_value()?; - } - GeneratedField::JoinType => { - if join_type__.is_some() { - return Err(serde::de::Error::duplicate_field("joinType")); - } - join_type__ = Some(map.next_value::()? as i32); - } - GeneratedField::JoinConstraint => { - if join_constraint__.is_some() { - return Err(serde::de::Error::duplicate_field("joinConstraint")); - } - join_constraint__ = Some(map.next_value::()? as i32); - } - GeneratedField::LeftJoinKey => { - if left_join_key__.is_some() { - return Err(serde::de::Error::duplicate_field("leftJoinKey")); - } - left_join_key__ = Some(map.next_value()?); - } - GeneratedField::RightJoinKey => { - if right_join_key__.is_some() { - return Err(serde::de::Error::duplicate_field("rightJoinKey")); - } - right_join_key__ = Some(map.next_value()?); - } - GeneratedField::NullEqualsNull => { - if null_equals_null__.is_some() { - return Err(serde::de::Error::duplicate_field("nullEqualsNull")); - } - null_equals_null__ = Some(map.next_value()?); - } - GeneratedField::Filter => { - if filter__.is_some() { - return Err(serde::de::Error::duplicate_field("filter")); - } - filter__ = map.next_value()?; - } - } - } - Ok(JoinNode { - left: left__, - right: right__, - join_type: join_type__.unwrap_or_default(), - join_constraint: join_constraint__.unwrap_or_default(), - left_join_key: left_join_key__.unwrap_or_default(), - right_join_key: right_join_key__.unwrap_or_default(), - null_equals_null: null_equals_null__.unwrap_or_default(), - filter: filter__, - }) - } - } - deserializer.deserialize_struct("datafusion.JoinNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for JoinOn { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.left.is_some() { - len += 1; - } - if self.right.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.JoinOn", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; - } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for JoinOn { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "left", - "right", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Left, - Right, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinOn; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.JoinOn") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut left__ = None; - let mut right__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); - } - left__ = map.next_value()?; - } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); - } - right__ = map.next_value()?; - } - } - } - Ok(JoinOn { - left: left__, - right: right__, - }) - } - } - deserializer.deserialize_struct("datafusion.JoinOn", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for JoinSide { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::LeftSide => "LEFT_SIDE", - Self::RightSide => "RIGHT_SIDE", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for JoinSide { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "LEFT_SIDE", - "RIGHT_SIDE", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinSide; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinSide::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinSide::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "LEFT_SIDE" => Ok(JoinSide::LeftSide), - "RIGHT_SIDE" => Ok(JoinSide::RightSide), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for JoinType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Inner => "INNER", - Self::Left => "LEFT", - Self::Right => "RIGHT", - Self::Full => "FULL", - Self::Leftsemi => "LEFTSEMI", - Self::Leftanti => "LEFTANTI", - Self::Rightsemi => "RIGHTSEMI", - Self::Rightanti => "RIGHTANTI", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for JoinType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "INNER", - "LEFT", - "RIGHT", - "FULL", - "LEFTSEMI", - "LEFTANTI", - "RIGHTSEMI", - "RIGHTANTI", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = JoinType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinType::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(JoinType::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "INNER" => Ok(JoinType::Inner), - "LEFT" => Ok(JoinType::Left), - "RIGHT" => Ok(JoinType::Right), - "FULL" => Ok(JoinType::Full), - "LEFTSEMI" => Ok(JoinType::Leftsemi), - "LEFTANTI" => Ok(JoinType::Leftanti), - "RIGHTSEMI" => Ok(JoinType::Rightsemi), - "RIGHTANTI" => Ok(JoinType::Rightanti), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for LikeNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.negated { - len += 1; - } - if self.expr.is_some() { - len += 1; - } - if self.pattern.is_some() { - len += 1; - } - if !self.escape_char.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LikeNode", len)?; - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.pattern.as_ref() { - struct_ser.serialize_field("pattern", v)?; - } - if !self.escape_char.is_empty() { - struct_ser.serialize_field("escapeChar", &self.escape_char)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LikeNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "negated", - "expr", - "pattern", - "escape_char", - "escapeChar", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Negated, - Expr, - Pattern, - EscapeChar, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "negated" => Ok(GeneratedField::Negated), - "expr" => Ok(GeneratedField::Expr), - "pattern" => Ok(GeneratedField::Pattern), - "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LikeNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LikeNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut negated__ = None; - let mut expr__ = None; - let mut pattern__ = None; - let mut escape_char__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); - } - negated__ = Some(map.next_value()?); - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Pattern => { - if pattern__.is_some() { - return Err(serde::de::Error::duplicate_field("pattern")); - } - pattern__ = map.next_value()?; - } - GeneratedField::EscapeChar => { - if escape_char__.is_some() { - return Err(serde::de::Error::duplicate_field("escapeChar")); - } - escape_char__ = Some(map.next_value()?); - } - } - } - Ok(LikeNode { - negated: negated__.unwrap_or_default(), - expr: expr__, - pattern: pattern__, - escape_char: escape_char__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.LikeNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for LimitNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.skip != 0 { - len += 1; - } - if self.fetch != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LimitNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.skip != 0 { - struct_ser.serialize_field("skip", ToString::to_string(&self.skip).as_str())?; - } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LimitNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "skip", - "fetch", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Skip, - Fetch, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "skip" => Ok(GeneratedField::Skip), - "fetch" => Ok(GeneratedField::Fetch), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LimitNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LimitNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut skip__ = None; - let mut fetch__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Skip => { - if skip__.is_some() { - return Err(serde::de::Error::duplicate_field("skip")); - } - skip__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); - } - fetch__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(LimitNode { - input: input__, - skip: skip__.unwrap_or_default(), - fetch: fetch__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.LimitNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for List { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.field_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.List", len)?; - if let Some(v) = self.field_type.as_ref() { - struct_ser.serialize_field("fieldType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for List { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "field_type", - "fieldType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - FieldType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "fieldType" | "field_type" => Ok(GeneratedField::FieldType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = List; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.List") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut field_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::FieldType => { - if field_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fieldType")); - } - field_type__ = map.next_value()?; - } - } - } - Ok(List { - field_type: field_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.List", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ListingTableScanNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.table_name.is_some() { - len += 1; - } - if !self.paths.is_empty() { - len += 1; - } - if !self.file_extension.is_empty() { - len += 1; - } - if self.projection.is_some() { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if !self.filters.is_empty() { - len += 1; - } - if !self.table_partition_cols.is_empty() { - len += 1; - } - if self.collect_stat { - len += 1; - } - if self.target_partitions != 0 { - len += 1; - } - if !self.file_sort_order.is_empty() { - len += 1; - } - if self.file_format_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ListingTableScanNode", len)?; - if let Some(v) = self.table_name.as_ref() { - struct_ser.serialize_field("tableName", v)?; - } - if !self.paths.is_empty() { - struct_ser.serialize_field("paths", &self.paths)?; - } - if !self.file_extension.is_empty() { - struct_ser.serialize_field("fileExtension", &self.file_extension)?; - } - if let Some(v) = self.projection.as_ref() { - struct_ser.serialize_field("projection", v)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if !self.filters.is_empty() { - struct_ser.serialize_field("filters", &self.filters)?; - } - if !self.table_partition_cols.is_empty() { - struct_ser.serialize_field("tablePartitionCols", &self.table_partition_cols)?; - } - if self.collect_stat { - struct_ser.serialize_field("collectStat", &self.collect_stat)?; - } - if self.target_partitions != 0 { - struct_ser.serialize_field("targetPartitions", &self.target_partitions)?; - } - if !self.file_sort_order.is_empty() { - struct_ser.serialize_field("fileSortOrder", &self.file_sort_order)?; - } - if let Some(v) = self.file_format_type.as_ref() { - match v { - listing_table_scan_node::FileFormatType::Csv(v) => { - struct_ser.serialize_field("csv", v)?; - } - listing_table_scan_node::FileFormatType::Parquet(v) => { - struct_ser.serialize_field("parquet", v)?; - } - listing_table_scan_node::FileFormatType::Avro(v) => { - struct_ser.serialize_field("avro", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ListingTableScanNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "table_name", - "tableName", - "paths", - "file_extension", - "fileExtension", - "projection", - "schema", - "filters", - "table_partition_cols", - "tablePartitionCols", - "collect_stat", - "collectStat", - "target_partitions", - "targetPartitions", - "file_sort_order", - "fileSortOrder", - "csv", - "parquet", - "avro", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - TableName, - Paths, - FileExtension, - Projection, - Schema, - Filters, - TablePartitionCols, - CollectStat, - TargetPartitions, - FileSortOrder, - Csv, - Parquet, - Avro, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "tableName" | "table_name" => Ok(GeneratedField::TableName), - "paths" => Ok(GeneratedField::Paths), - "fileExtension" | "file_extension" => Ok(GeneratedField::FileExtension), - "projection" => Ok(GeneratedField::Projection), - "schema" => Ok(GeneratedField::Schema), - "filters" => Ok(GeneratedField::Filters), - "tablePartitionCols" | "table_partition_cols" => Ok(GeneratedField::TablePartitionCols), - "collectStat" | "collect_stat" => Ok(GeneratedField::CollectStat), - "targetPartitions" | "target_partitions" => Ok(GeneratedField::TargetPartitions), - "fileSortOrder" | "file_sort_order" => Ok(GeneratedField::FileSortOrder), - "csv" => Ok(GeneratedField::Csv), - "parquet" => Ok(GeneratedField::Parquet), - "avro" => Ok(GeneratedField::Avro), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ListingTableScanNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ListingTableScanNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut table_name__ = None; - let mut paths__ = None; - let mut file_extension__ = None; - let mut projection__ = None; - let mut schema__ = None; - let mut filters__ = None; - let mut table_partition_cols__ = None; - let mut collect_stat__ = None; - let mut target_partitions__ = None; - let mut file_sort_order__ = None; - let mut file_format_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::TableName => { - if table_name__.is_some() { - return Err(serde::de::Error::duplicate_field("tableName")); - } - table_name__ = map.next_value()?; - } - GeneratedField::Paths => { - if paths__.is_some() { - return Err(serde::de::Error::duplicate_field("paths")); - } - paths__ = Some(map.next_value()?); - } - GeneratedField::FileExtension => { - if file_extension__.is_some() { - return Err(serde::de::Error::duplicate_field("fileExtension")); - } - file_extension__ = Some(map.next_value()?); - } - GeneratedField::Projection => { - if projection__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - projection__ = map.next_value()?; - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::Filters => { - if filters__.is_some() { - return Err(serde::de::Error::duplicate_field("filters")); - } - filters__ = Some(map.next_value()?); - } - GeneratedField::TablePartitionCols => { - if table_partition_cols__.is_some() { - return Err(serde::de::Error::duplicate_field("tablePartitionCols")); - } - table_partition_cols__ = Some(map.next_value()?); - } - GeneratedField::CollectStat => { - if collect_stat__.is_some() { - return Err(serde::de::Error::duplicate_field("collectStat")); - } - collect_stat__ = Some(map.next_value()?); - } - GeneratedField::TargetPartitions => { - if target_partitions__.is_some() { - return Err(serde::de::Error::duplicate_field("targetPartitions")); - } - target_partitions__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::FileSortOrder => { - if file_sort_order__.is_some() { - return Err(serde::de::Error::duplicate_field("fileSortOrder")); - } - file_sort_order__ = Some(map.next_value()?); - } - GeneratedField::Csv => { - if file_format_type__.is_some() { - return Err(serde::de::Error::duplicate_field("csv")); - } - file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Csv) -; - } - GeneratedField::Parquet => { - if file_format_type__.is_some() { - return Err(serde::de::Error::duplicate_field("parquet")); - } - file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Parquet) -; - } - GeneratedField::Avro => { - if file_format_type__.is_some() { - return Err(serde::de::Error::duplicate_field("avro")); - } - file_format_type__ = map.next_value::<::std::option::Option<_>>()?.map(listing_table_scan_node::FileFormatType::Avro) -; - } - } - } - Ok(ListingTableScanNode { - table_name: table_name__, - paths: paths__.unwrap_or_default(), - file_extension: file_extension__.unwrap_or_default(), - projection: projection__, - schema: schema__, - filters: filters__.unwrap_or_default(), - table_partition_cols: table_partition_cols__.unwrap_or_default(), - collect_stat: collect_stat__.unwrap_or_default(), - target_partitions: target_partitions__.unwrap_or_default(), - file_sort_order: file_sort_order__.unwrap_or_default(), - file_format_type: file_format_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.ListingTableScanNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for LocalLimitExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.fetch != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LocalLimitExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", &self.fetch)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LocalLimitExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "fetch", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Fetch, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "fetch" => Ok(GeneratedField::Fetch), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LocalLimitExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LocalLimitExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut fetch__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); - } - fetch__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(LocalLimitExecNode { - input: input__, - fetch: fetch__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.LocalLimitExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for LogicalExprList { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprList", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LogicalExprList { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalExprList; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalExprList") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - } - } - Ok(LogicalExprList { - expr: expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.LogicalExprList", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for LogicalExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNode", len)?; - if let Some(v) = self.expr_type.as_ref() { - match v { - logical_expr_node::ExprType::Column(v) => { - struct_ser.serialize_field("column", v)?; - } - logical_expr_node::ExprType::Alias(v) => { - struct_ser.serialize_field("alias", v)?; - } - logical_expr_node::ExprType::Literal(v) => { - struct_ser.serialize_field("literal", v)?; - } - logical_expr_node::ExprType::BinaryExpr(v) => { - struct_ser.serialize_field("binaryExpr", v)?; - } - logical_expr_node::ExprType::AggregateExpr(v) => { - struct_ser.serialize_field("aggregateExpr", v)?; - } - logical_expr_node::ExprType::IsNullExpr(v) => { - struct_ser.serialize_field("isNullExpr", v)?; - } - logical_expr_node::ExprType::IsNotNullExpr(v) => { - struct_ser.serialize_field("isNotNullExpr", v)?; - } - logical_expr_node::ExprType::NotExpr(v) => { - struct_ser.serialize_field("notExpr", v)?; - } - logical_expr_node::ExprType::Between(v) => { - struct_ser.serialize_field("between", v)?; - } - logical_expr_node::ExprType::Case(v) => { - struct_ser.serialize_field("case", v)?; - } - logical_expr_node::ExprType::Cast(v) => { - struct_ser.serialize_field("cast", v)?; - } - logical_expr_node::ExprType::Sort(v) => { - struct_ser.serialize_field("sort", v)?; - } - logical_expr_node::ExprType::Negative(v) => { - struct_ser.serialize_field("negative", v)?; - } - logical_expr_node::ExprType::InList(v) => { - struct_ser.serialize_field("inList", v)?; - } - logical_expr_node::ExprType::Wildcard(v) => { - struct_ser.serialize_field("wildcard", v)?; - } - logical_expr_node::ExprType::ScalarFunction(v) => { - struct_ser.serialize_field("scalarFunction", v)?; - } - logical_expr_node::ExprType::TryCast(v) => { - struct_ser.serialize_field("tryCast", v)?; - } - logical_expr_node::ExprType::WindowExpr(v) => { - struct_ser.serialize_field("windowExpr", v)?; - } - logical_expr_node::ExprType::AggregateUdfExpr(v) => { - struct_ser.serialize_field("aggregateUdfExpr", v)?; - } - logical_expr_node::ExprType::ScalarUdfExpr(v) => { - struct_ser.serialize_field("scalarUdfExpr", v)?; - } - logical_expr_node::ExprType::GetIndexedField(v) => { - struct_ser.serialize_field("getIndexedField", v)?; - } - logical_expr_node::ExprType::GroupingSet(v) => { - struct_ser.serialize_field("groupingSet", v)?; - } - logical_expr_node::ExprType::Cube(v) => { - struct_ser.serialize_field("cube", v)?; - } - logical_expr_node::ExprType::Rollup(v) => { - struct_ser.serialize_field("rollup", v)?; - } - logical_expr_node::ExprType::IsTrue(v) => { - struct_ser.serialize_field("isTrue", v)?; - } - logical_expr_node::ExprType::IsFalse(v) => { - struct_ser.serialize_field("isFalse", v)?; - } - logical_expr_node::ExprType::IsUnknown(v) => { - struct_ser.serialize_field("isUnknown", v)?; - } - logical_expr_node::ExprType::IsNotTrue(v) => { - struct_ser.serialize_field("isNotTrue", v)?; - } - logical_expr_node::ExprType::IsNotFalse(v) => { - struct_ser.serialize_field("isNotFalse", v)?; - } - logical_expr_node::ExprType::IsNotUnknown(v) => { - struct_ser.serialize_field("isNotUnknown", v)?; - } - logical_expr_node::ExprType::Like(v) => { - struct_ser.serialize_field("like", v)?; - } - logical_expr_node::ExprType::Ilike(v) => { - struct_ser.serialize_field("ilike", v)?; - } - logical_expr_node::ExprType::SimilarTo(v) => { - struct_ser.serialize_field("similarTo", v)?; - } - logical_expr_node::ExprType::Placeholder(v) => { - struct_ser.serialize_field("placeholder", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LogicalExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "column", - "alias", - "literal", - "binary_expr", - "binaryExpr", - "aggregate_expr", - "aggregateExpr", - "is_null_expr", - "isNullExpr", - "is_not_null_expr", - "isNotNullExpr", - "not_expr", - "notExpr", - "between", - "case_", - "case", - "cast", - "sort", - "negative", - "in_list", - "inList", - "wildcard", - "scalar_function", - "scalarFunction", - "try_cast", - "tryCast", - "window_expr", - "windowExpr", - "aggregate_udf_expr", - "aggregateUdfExpr", - "scalar_udf_expr", - "scalarUdfExpr", - "get_indexed_field", - "getIndexedField", - "grouping_set", - "groupingSet", - "cube", - "rollup", - "is_true", - "isTrue", - "is_false", - "isFalse", - "is_unknown", - "isUnknown", - "is_not_true", - "isNotTrue", - "is_not_false", - "isNotFalse", - "is_not_unknown", - "isNotUnknown", - "like", - "ilike", - "similar_to", - "similarTo", - "placeholder", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Column, - Alias, - Literal, - BinaryExpr, - AggregateExpr, - IsNullExpr, - IsNotNullExpr, - NotExpr, - Between, - Case, - Cast, - Sort, - Negative, - InList, - Wildcard, - ScalarFunction, - TryCast, - WindowExpr, - AggregateUdfExpr, - ScalarUdfExpr, - GetIndexedField, - GroupingSet, - Cube, - Rollup, - IsTrue, - IsFalse, - IsUnknown, - IsNotTrue, - IsNotFalse, - IsNotUnknown, - Like, - Ilike, - SimilarTo, - Placeholder, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "column" => Ok(GeneratedField::Column), - "alias" => Ok(GeneratedField::Alias), - "literal" => Ok(GeneratedField::Literal), - "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr), - "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr), - "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr), - "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr), - "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr), - "between" => Ok(GeneratedField::Between), - "case" | "case_" => Ok(GeneratedField::Case), - "cast" => Ok(GeneratedField::Cast), - "sort" => Ok(GeneratedField::Sort), - "negative" => Ok(GeneratedField::Negative), - "inList" | "in_list" => Ok(GeneratedField::InList), - "wildcard" => Ok(GeneratedField::Wildcard), - "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction), - "tryCast" | "try_cast" => Ok(GeneratedField::TryCast), - "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), - "aggregateUdfExpr" | "aggregate_udf_expr" => Ok(GeneratedField::AggregateUdfExpr), - "scalarUdfExpr" | "scalar_udf_expr" => Ok(GeneratedField::ScalarUdfExpr), - "getIndexedField" | "get_indexed_field" => Ok(GeneratedField::GetIndexedField), - "groupingSet" | "grouping_set" => Ok(GeneratedField::GroupingSet), - "cube" => Ok(GeneratedField::Cube), - "rollup" => Ok(GeneratedField::Rollup), - "isTrue" | "is_true" => Ok(GeneratedField::IsTrue), - "isFalse" | "is_false" => Ok(GeneratedField::IsFalse), - "isUnknown" | "is_unknown" => Ok(GeneratedField::IsUnknown), - "isNotTrue" | "is_not_true" => Ok(GeneratedField::IsNotTrue), - "isNotFalse" | "is_not_false" => Ok(GeneratedField::IsNotFalse), - "isNotUnknown" | "is_not_unknown" => Ok(GeneratedField::IsNotUnknown), - "like" => Ok(GeneratedField::Like), - "ilike" => Ok(GeneratedField::Ilike), - "similarTo" | "similar_to" => Ok(GeneratedField::SimilarTo), - "placeholder" => Ok(GeneratedField::Placeholder), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Column => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("column")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Column) -; - } - GeneratedField::Alias => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("alias")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Alias) -; - } - GeneratedField::Literal => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("literal")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Literal) -; - } - GeneratedField::BinaryExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("binaryExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::BinaryExpr) -; - } - GeneratedField::AggregateExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregateExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateExpr) -; - } - GeneratedField::IsNullExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNullExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNullExpr) -; - } - GeneratedField::IsNotNullExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotNullExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotNullExpr) -; - } - GeneratedField::NotExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("notExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::NotExpr) -; - } - GeneratedField::Between => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("between")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Between) -; - } - GeneratedField::Case => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("case")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Case) -; - } - GeneratedField::Cast => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("cast")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cast) -; - } - GeneratedField::Sort => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("sort")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Sort) -; - } - GeneratedField::Negative => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("negative")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Negative) -; - } - GeneratedField::InList => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("inList")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::InList) -; - } - GeneratedField::Wildcard => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("wildcard")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Wildcard); - } - GeneratedField::ScalarFunction => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("scalarFunction")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarFunction) -; - } - GeneratedField::TryCast => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("tryCast")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::TryCast) -; - } - GeneratedField::WindowExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("windowExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::WindowExpr) -; - } - GeneratedField::AggregateUdfExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregateUdfExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::AggregateUdfExpr) -; - } - GeneratedField::ScalarUdfExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("scalarUdfExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::ScalarUdfExpr) -; - } - GeneratedField::GetIndexedField => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("getIndexedField")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GetIndexedField) -; - } - GeneratedField::GroupingSet => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("groupingSet")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::GroupingSet) -; - } - GeneratedField::Cube => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("cube")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Cube) -; - } - GeneratedField::Rollup => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("rollup")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Rollup) -; - } - GeneratedField::IsTrue => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isTrue")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsTrue) -; - } - GeneratedField::IsFalse => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isFalse")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsFalse) -; - } - GeneratedField::IsUnknown => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isUnknown")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsUnknown) -; - } - GeneratedField::IsNotTrue => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotTrue")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotTrue) -; - } - GeneratedField::IsNotFalse => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotFalse")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotFalse) -; - } - GeneratedField::IsNotUnknown => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotUnknown")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::IsNotUnknown) -; - } - GeneratedField::Like => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("like")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Like) -; - } - GeneratedField::Ilike => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("ilike")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Ilike) -; - } - GeneratedField::SimilarTo => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("similarTo")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::SimilarTo) -; - } - GeneratedField::Placeholder => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("placeholder")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_expr_node::ExprType::Placeholder) -; - } - } - } - Ok(LogicalExprNode { - expr_type: expr_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.LogicalExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for LogicalExprNodeCollection { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.logical_expr_nodes.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExprNodeCollection", len)?; - if !self.logical_expr_nodes.is_empty() { - struct_ser.serialize_field("logicalExprNodes", &self.logical_expr_nodes)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LogicalExprNodeCollection { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "logical_expr_nodes", - "logicalExprNodes", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - LogicalExprNodes, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "logicalExprNodes" | "logical_expr_nodes" => Ok(GeneratedField::LogicalExprNodes), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalExprNodeCollection; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalExprNodeCollection") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut logical_expr_nodes__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::LogicalExprNodes => { - if logical_expr_nodes__.is_some() { - return Err(serde::de::Error::duplicate_field("logicalExprNodes")); - } - logical_expr_nodes__ = Some(map.next_value()?); - } - } - } - Ok(LogicalExprNodeCollection { - logical_expr_nodes: logical_expr_nodes__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.LogicalExprNodeCollection", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for LogicalExtensionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.node.is_empty() { - len += 1; - } - if !self.inputs.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalExtensionNode", len)?; - if !self.node.is_empty() { - struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?; - } - if !self.inputs.is_empty() { - struct_ser.serialize_field("inputs", &self.inputs)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LogicalExtensionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "node", - "inputs", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Node, - Inputs, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "node" => Ok(GeneratedField::Node), - "inputs" => Ok(GeneratedField::Inputs), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalExtensionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalExtensionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut node__ = None; - let mut inputs__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Node => { - if node__.is_some() { - return Err(serde::de::Error::duplicate_field("node")); - } - node__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Inputs => { - if inputs__.is_some() { - return Err(serde::de::Error::duplicate_field("inputs")); - } - inputs__ = Some(map.next_value()?); - } - } - } - Ok(LogicalExtensionNode { - node: node__.unwrap_or_default(), - inputs: inputs__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.LogicalExtensionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for LogicalPlanNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.logical_plan_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.LogicalPlanNode", len)?; - if let Some(v) = self.logical_plan_type.as_ref() { - match v { - logical_plan_node::LogicalPlanType::ListingScan(v) => { - struct_ser.serialize_field("listingScan", v)?; - } - logical_plan_node::LogicalPlanType::Projection(v) => { - struct_ser.serialize_field("projection", v)?; - } - logical_plan_node::LogicalPlanType::Selection(v) => { - struct_ser.serialize_field("selection", v)?; - } - logical_plan_node::LogicalPlanType::Limit(v) => { - struct_ser.serialize_field("limit", v)?; - } - logical_plan_node::LogicalPlanType::Aggregate(v) => { - struct_ser.serialize_field("aggregate", v)?; - } - logical_plan_node::LogicalPlanType::Join(v) => { - struct_ser.serialize_field("join", v)?; - } - logical_plan_node::LogicalPlanType::Sort(v) => { - struct_ser.serialize_field("sort", v)?; - } - logical_plan_node::LogicalPlanType::Repartition(v) => { - struct_ser.serialize_field("repartition", v)?; - } - logical_plan_node::LogicalPlanType::EmptyRelation(v) => { - struct_ser.serialize_field("emptyRelation", v)?; - } - logical_plan_node::LogicalPlanType::CreateExternalTable(v) => { - struct_ser.serialize_field("createExternalTable", v)?; - } - logical_plan_node::LogicalPlanType::Explain(v) => { - struct_ser.serialize_field("explain", v)?; - } - logical_plan_node::LogicalPlanType::Window(v) => { - struct_ser.serialize_field("window", v)?; - } - logical_plan_node::LogicalPlanType::Analyze(v) => { - struct_ser.serialize_field("analyze", v)?; - } - logical_plan_node::LogicalPlanType::CrossJoin(v) => { - struct_ser.serialize_field("crossJoin", v)?; - } - logical_plan_node::LogicalPlanType::Values(v) => { - struct_ser.serialize_field("values", v)?; - } - logical_plan_node::LogicalPlanType::Extension(v) => { - struct_ser.serialize_field("extension", v)?; - } - logical_plan_node::LogicalPlanType::CreateCatalogSchema(v) => { - struct_ser.serialize_field("createCatalogSchema", v)?; - } - logical_plan_node::LogicalPlanType::Union(v) => { - struct_ser.serialize_field("union", v)?; - } - logical_plan_node::LogicalPlanType::CreateCatalog(v) => { - struct_ser.serialize_field("createCatalog", v)?; - } - logical_plan_node::LogicalPlanType::SubqueryAlias(v) => { - struct_ser.serialize_field("subqueryAlias", v)?; - } - logical_plan_node::LogicalPlanType::CreateView(v) => { - struct_ser.serialize_field("createView", v)?; - } - logical_plan_node::LogicalPlanType::Distinct(v) => { - struct_ser.serialize_field("distinct", v)?; - } - logical_plan_node::LogicalPlanType::ViewScan(v) => { - struct_ser.serialize_field("viewScan", v)?; - } - logical_plan_node::LogicalPlanType::CustomScan(v) => { - struct_ser.serialize_field("customScan", v)?; - } - logical_plan_node::LogicalPlanType::Prepare(v) => { - struct_ser.serialize_field("prepare", v)?; - } - logical_plan_node::LogicalPlanType::DropView(v) => { - struct_ser.serialize_field("dropView", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for LogicalPlanNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "listing_scan", - "listingScan", - "projection", - "selection", - "limit", - "aggregate", - "join", - "sort", - "repartition", - "empty_relation", - "emptyRelation", - "create_external_table", - "createExternalTable", - "explain", - "window", - "analyze", - "cross_join", - "crossJoin", - "values", - "extension", - "create_catalog_schema", - "createCatalogSchema", - "union", - "create_catalog", - "createCatalog", - "subquery_alias", - "subqueryAlias", - "create_view", - "createView", - "distinct", - "view_scan", - "viewScan", - "custom_scan", - "customScan", - "prepare", - "drop_view", - "dropView", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - ListingScan, - Projection, - Selection, - Limit, - Aggregate, - Join, - Sort, - Repartition, - EmptyRelation, - CreateExternalTable, - Explain, - Window, - Analyze, - CrossJoin, - Values, - Extension, - CreateCatalogSchema, - Union, - CreateCatalog, - SubqueryAlias, - CreateView, - Distinct, - ViewScan, - CustomScan, - Prepare, - DropView, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "listingScan" | "listing_scan" => Ok(GeneratedField::ListingScan), - "projection" => Ok(GeneratedField::Projection), - "selection" => Ok(GeneratedField::Selection), - "limit" => Ok(GeneratedField::Limit), - "aggregate" => Ok(GeneratedField::Aggregate), - "join" => Ok(GeneratedField::Join), - "sort" => Ok(GeneratedField::Sort), - "repartition" => Ok(GeneratedField::Repartition), - "emptyRelation" | "empty_relation" => Ok(GeneratedField::EmptyRelation), - "createExternalTable" | "create_external_table" => Ok(GeneratedField::CreateExternalTable), - "explain" => Ok(GeneratedField::Explain), - "window" => Ok(GeneratedField::Window), - "analyze" => Ok(GeneratedField::Analyze), - "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin), - "values" => Ok(GeneratedField::Values), - "extension" => Ok(GeneratedField::Extension), - "createCatalogSchema" | "create_catalog_schema" => Ok(GeneratedField::CreateCatalogSchema), - "union" => Ok(GeneratedField::Union), - "createCatalog" | "create_catalog" => Ok(GeneratedField::CreateCatalog), - "subqueryAlias" | "subquery_alias" => Ok(GeneratedField::SubqueryAlias), - "createView" | "create_view" => Ok(GeneratedField::CreateView), - "distinct" => Ok(GeneratedField::Distinct), - "viewScan" | "view_scan" => Ok(GeneratedField::ViewScan), - "customScan" | "custom_scan" => Ok(GeneratedField::CustomScan), - "prepare" => Ok(GeneratedField::Prepare), - "dropView" | "drop_view" => Ok(GeneratedField::DropView), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = LogicalPlanNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.LogicalPlanNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut logical_plan_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::ListingScan => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("listingScan")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ListingScan) -; - } - GeneratedField::Projection => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Projection) -; - } - GeneratedField::Selection => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("selection")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Selection) -; - } - GeneratedField::Limit => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("limit")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Limit) -; - } - GeneratedField::Aggregate => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregate")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Aggregate) -; - } - GeneratedField::Join => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("join")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Join) -; - } - GeneratedField::Sort => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("sort")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Sort) -; - } - GeneratedField::Repartition => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("repartition")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Repartition) -; - } - GeneratedField::EmptyRelation => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("emptyRelation")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::EmptyRelation) -; - } - GeneratedField::CreateExternalTable => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createExternalTable")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateExternalTable) -; - } - GeneratedField::Explain => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("explain")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Explain) -; - } - GeneratedField::Window => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("window")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Window) -; - } - GeneratedField::Analyze => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("analyze")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Analyze) -; - } - GeneratedField::CrossJoin => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("crossJoin")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CrossJoin) -; - } - GeneratedField::Values => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("values")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Values) -; - } - GeneratedField::Extension => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("extension")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Extension) -; - } - GeneratedField::CreateCatalogSchema => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createCatalogSchema")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalogSchema) -; - } - GeneratedField::Union => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("union")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Union) -; - } - GeneratedField::CreateCatalog => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createCatalog")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateCatalog) -; - } - GeneratedField::SubqueryAlias => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("subqueryAlias")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::SubqueryAlias) -; - } - GeneratedField::CreateView => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("createView")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CreateView) -; - } - GeneratedField::Distinct => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("distinct")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Distinct) -; - } - GeneratedField::ViewScan => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("viewScan")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::ViewScan) -; - } - GeneratedField::CustomScan => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("customScan")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::CustomScan) -; - } - GeneratedField::Prepare => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("prepare")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::Prepare) -; - } - GeneratedField::DropView => { - if logical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("dropView")); - } - logical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(logical_plan_node::LogicalPlanType::DropView) -; - } - } - } - Ok(LogicalPlanNode { - logical_plan_type: logical_plan_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.LogicalPlanNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Map { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.field_type.is_some() { - len += 1; - } - if self.keys_sorted { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Map", len)?; - if let Some(v) = self.field_type.as_ref() { - struct_ser.serialize_field("fieldType", v)?; - } - if self.keys_sorted { - struct_ser.serialize_field("keysSorted", &self.keys_sorted)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Map { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "field_type", - "fieldType", - "keys_sorted", - "keysSorted", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - FieldType, - KeysSorted, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "fieldType" | "field_type" => Ok(GeneratedField::FieldType), - "keysSorted" | "keys_sorted" => Ok(GeneratedField::KeysSorted), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Map; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Map") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut field_type__ = None; - let mut keys_sorted__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::FieldType => { - if field_type__.is_some() { - return Err(serde::de::Error::duplicate_field("fieldType")); - } - field_type__ = map.next_value()?; - } - GeneratedField::KeysSorted => { - if keys_sorted__.is_some() { - return Err(serde::de::Error::duplicate_field("keysSorted")); - } - keys_sorted__ = Some(map.next_value()?); - } - } - } - Ok(Map { - field_type: field_type__, - keys_sorted: keys_sorted__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Map", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MaybeFilter { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.MaybeFilter", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MaybeFilter { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MaybeFilter; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.MaybeFilter") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(MaybeFilter { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.MaybeFilter", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for MaybePhysicalSortExprs { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.sort_expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.MaybePhysicalSortExprs", len)?; - if !self.sort_expr.is_empty() { - struct_ser.serialize_field("sortExpr", &self.sort_expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for MaybePhysicalSortExprs { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "sort_expr", - "sortExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - SortExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "sortExpr" | "sort_expr" => Ok(GeneratedField::SortExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = MaybePhysicalSortExprs; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.MaybePhysicalSortExprs") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut sort_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::SortExpr => { - if sort_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("sortExpr")); - } - sort_expr__ = Some(map.next_value()?); - } - } - } - Ok(MaybePhysicalSortExprs { - sort_expr: sort_expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.MaybePhysicalSortExprs", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for NegativeNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.NegativeNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for NegativeNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = NegativeNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.NegativeNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(NegativeNode { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.NegativeNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for NestedLoopJoinExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.left.is_some() { - len += 1; - } - if self.right.is_some() { - len += 1; - } - if self.join_type != 0 { - len += 1; - } - if self.filter.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.NestedLoopJoinExecNode", len)?; - if let Some(v) = self.left.as_ref() { - struct_ser.serialize_field("left", v)?; - } - if let Some(v) = self.right.as_ref() { - struct_ser.serialize_field("right", v)?; - } - if self.join_type != 0 { - let v = JoinType::from_i32(self.join_type) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?; - struct_ser.serialize_field("joinType", &v)?; - } - if let Some(v) = self.filter.as_ref() { - struct_ser.serialize_field("filter", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for NestedLoopJoinExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "left", - "right", - "join_type", - "joinType", - "filter", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Left, - Right, - JoinType, - Filter, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "left" => Ok(GeneratedField::Left), - "right" => Ok(GeneratedField::Right), - "joinType" | "join_type" => Ok(GeneratedField::JoinType), - "filter" => Ok(GeneratedField::Filter), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = NestedLoopJoinExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.NestedLoopJoinExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut left__ = None; - let mut right__ = None; - let mut join_type__ = None; - let mut filter__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Left => { - if left__.is_some() { - return Err(serde::de::Error::duplicate_field("left")); - } - left__ = map.next_value()?; - } - GeneratedField::Right => { - if right__.is_some() { - return Err(serde::de::Error::duplicate_field("right")); - } - right__ = map.next_value()?; - } - GeneratedField::JoinType => { - if join_type__.is_some() { - return Err(serde::de::Error::duplicate_field("joinType")); - } - join_type__ = Some(map.next_value::()? as i32); - } - GeneratedField::Filter => { - if filter__.is_some() { - return Err(serde::de::Error::duplicate_field("filter")); - } - filter__ = map.next_value()?; - } - } - } - Ok(NestedLoopJoinExecNode { - left: left__, - right: right__, - join_type: join_type__.unwrap_or_default(), - filter: filter__, - }) - } - } - deserializer.deserialize_struct("datafusion.NestedLoopJoinExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Not { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Not", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Not { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Not; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Not") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(Not { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.Not", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for OptimizedLogicalPlanType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.optimizer_name.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedLogicalPlanType", len)?; - if !self.optimizer_name.is_empty() { - struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for OptimizedLogicalPlanType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "optimizer_name", - "optimizerName", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - OptimizerName, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OptimizedLogicalPlanType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.OptimizedLogicalPlanType") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut optimizer_name__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::OptimizerName => { - if optimizer_name__.is_some() { - return Err(serde::de::Error::duplicate_field("optimizerName")); - } - optimizer_name__ = Some(map.next_value()?); - } - } - } - Ok(OptimizedLogicalPlanType { - optimizer_name: optimizer_name__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.OptimizedLogicalPlanType", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for OptimizedPhysicalPlanType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.optimizer_name.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.OptimizedPhysicalPlanType", len)?; - if !self.optimizer_name.is_empty() { - struct_ser.serialize_field("optimizerName", &self.optimizer_name)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for OptimizedPhysicalPlanType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "optimizer_name", - "optimizerName", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - OptimizerName, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "optimizerName" | "optimizer_name" => Ok(GeneratedField::OptimizerName), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OptimizedPhysicalPlanType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.OptimizedPhysicalPlanType") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut optimizer_name__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::OptimizerName => { - if optimizer_name__.is_some() { - return Err(serde::de::Error::duplicate_field("optimizerName")); - } - optimizer_name__ = Some(map.next_value()?); - } - } - } - Ok(OptimizedPhysicalPlanType { - optimizer_name: optimizer_name__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.OptimizedPhysicalPlanType", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for OwnedTableReference { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.table_reference_enum.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.OwnedTableReference", len)?; - if let Some(v) = self.table_reference_enum.as_ref() { - match v { - owned_table_reference::TableReferenceEnum::Bare(v) => { - struct_ser.serialize_field("bare", v)?; - } - owned_table_reference::TableReferenceEnum::Partial(v) => { - struct_ser.serialize_field("partial", v)?; - } - owned_table_reference::TableReferenceEnum::Full(v) => { - struct_ser.serialize_field("full", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for OwnedTableReference { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "bare", - "partial", - "full", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Bare, - Partial, - Full, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "bare" => Ok(GeneratedField::Bare), - "partial" => Ok(GeneratedField::Partial), - "full" => Ok(GeneratedField::Full), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = OwnedTableReference; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.OwnedTableReference") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut table_reference_enum__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Bare => { - if table_reference_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("bare")); - } - table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Bare) -; - } - GeneratedField::Partial => { - if table_reference_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("partial")); - } - table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Partial) -; - } - GeneratedField::Full => { - if table_reference_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("full")); - } - table_reference_enum__ = map.next_value::<::std::option::Option<_>>()?.map(owned_table_reference::TableReferenceEnum::Full) -; - } - } - } - Ok(OwnedTableReference { - table_reference_enum: table_reference_enum__, - }) - } - } - deserializer.deserialize_struct("datafusion.OwnedTableReference", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ParquetFormat { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let len = 0; - let struct_ser = serializer.serialize_struct("datafusion.ParquetFormat", len)?; - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ParquetFormat { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - Err(serde::de::Error::unknown_field(value, FIELDS)) - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ParquetFormat; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ParquetFormat") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - while map.next_key::()?.is_some() { - let _ = map.next_value::()?; - } - Ok(ParquetFormat { - }) - } - } - deserializer.deserialize_struct("datafusion.ParquetFormat", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ParquetScanExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.base_conf.is_some() { - len += 1; - } - if self.predicate.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ParquetScanExecNode", len)?; - if let Some(v) = self.base_conf.as_ref() { - struct_ser.serialize_field("baseConf", v)?; - } - if let Some(v) = self.predicate.as_ref() { - struct_ser.serialize_field("predicate", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ParquetScanExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "base_conf", - "baseConf", - "predicate", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - BaseConf, - Predicate, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "baseConf" | "base_conf" => Ok(GeneratedField::BaseConf), - "predicate" => Ok(GeneratedField::Predicate), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ParquetScanExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ParquetScanExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut base_conf__ = None; - let mut predicate__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::BaseConf => { - if base_conf__.is_some() { - return Err(serde::de::Error::duplicate_field("baseConf")); - } - base_conf__ = map.next_value()?; - } - GeneratedField::Predicate => { - if predicate__.is_some() { - return Err(serde::de::Error::duplicate_field("predicate")); - } - predicate__ = map.next_value()?; - } - } - } - Ok(ParquetScanExecNode { - base_conf: base_conf__, - predicate: predicate__, - }) - } - } - deserializer.deserialize_struct("datafusion.ParquetScanExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PartialTableReference { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.schema.is_empty() { - len += 1; - } - if !self.table.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PartialTableReference", len)?; - if !self.schema.is_empty() { - struct_ser.serialize_field("schema", &self.schema)?; - } - if !self.table.is_empty() { - struct_ser.serialize_field("table", &self.table)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PartialTableReference { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "schema", - "table", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Schema, - Table, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "schema" => Ok(GeneratedField::Schema), - "table" => Ok(GeneratedField::Table), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PartialTableReference; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PartialTableReference") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut schema__ = None; - let mut table__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = Some(map.next_value()?); - } - GeneratedField::Table => { - if table__.is_some() { - return Err(serde::de::Error::duplicate_field("table")); - } - table__ = Some(map.next_value()?); - } - } - } - Ok(PartialTableReference { - schema: schema__.unwrap_or_default(), - table: table__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PartialTableReference", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PartitionMode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::CollectLeft => "COLLECT_LEFT", - Self::Partitioned => "PARTITIONED", - Self::Auto => "AUTO", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for PartitionMode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "COLLECT_LEFT", - "PARTITIONED", - "AUTO", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PartitionMode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(PartitionMode::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(PartitionMode::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "COLLECT_LEFT" => Ok(PartitionMode::CollectLeft), - "PARTITIONED" => Ok(PartitionMode::Partitioned), - "AUTO" => Ok(PartitionMode::Auto), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for PartitionStats { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.num_rows != 0 { - len += 1; - } - if self.num_batches != 0 { - len += 1; - } - if self.num_bytes != 0 { - len += 1; - } - if !self.column_stats.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PartitionStats", len)?; - if self.num_rows != 0 { - struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?; - } - if self.num_batches != 0 { - struct_ser.serialize_field("numBatches", ToString::to_string(&self.num_batches).as_str())?; - } - if self.num_bytes != 0 { - struct_ser.serialize_field("numBytes", ToString::to_string(&self.num_bytes).as_str())?; - } - if !self.column_stats.is_empty() { - struct_ser.serialize_field("columnStats", &self.column_stats)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PartitionStats { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "num_rows", - "numRows", - "num_batches", - "numBatches", - "num_bytes", - "numBytes", - "column_stats", - "columnStats", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - NumRows, - NumBatches, - NumBytes, - ColumnStats, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "numRows" | "num_rows" => Ok(GeneratedField::NumRows), - "numBatches" | "num_batches" => Ok(GeneratedField::NumBatches), - "numBytes" | "num_bytes" => Ok(GeneratedField::NumBytes), - "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PartitionStats; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PartitionStats") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut num_rows__ = None; - let mut num_batches__ = None; - let mut num_bytes__ = None; - let mut column_stats__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::NumRows => { - if num_rows__.is_some() { - return Err(serde::de::Error::duplicate_field("numRows")); - } - num_rows__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::NumBatches => { - if num_batches__.is_some() { - return Err(serde::de::Error::duplicate_field("numBatches")); - } - num_batches__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::NumBytes => { - if num_bytes__.is_some() { - return Err(serde::de::Error::duplicate_field("numBytes")); - } - num_bytes__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::ColumnStats => { - if column_stats__.is_some() { - return Err(serde::de::Error::duplicate_field("columnStats")); - } - column_stats__ = Some(map.next_value()?); - } - } - } - Ok(PartitionStats { - num_rows: num_rows__.unwrap_or_default(), - num_batches: num_batches__.unwrap_or_default(), - num_bytes: num_bytes__.unwrap_or_default(), - column_stats: column_stats__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PartitionStats", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PartitionedFile { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.path.is_empty() { - len += 1; - } - if self.size != 0 { - len += 1; - } - if self.last_modified_ns != 0 { - len += 1; - } - if !self.partition_values.is_empty() { - len += 1; - } - if self.range.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PartitionedFile", len)?; - if !self.path.is_empty() { - struct_ser.serialize_field("path", &self.path)?; - } - if self.size != 0 { - struct_ser.serialize_field("size", ToString::to_string(&self.size).as_str())?; - } - if self.last_modified_ns != 0 { - struct_ser.serialize_field("lastModifiedNs", ToString::to_string(&self.last_modified_ns).as_str())?; - } - if !self.partition_values.is_empty() { - struct_ser.serialize_field("partitionValues", &self.partition_values)?; - } - if let Some(v) = self.range.as_ref() { - struct_ser.serialize_field("range", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PartitionedFile { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "path", - "size", - "last_modified_ns", - "lastModifiedNs", - "partition_values", - "partitionValues", - "range", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Path, - Size, - LastModifiedNs, - PartitionValues, - Range, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "path" => Ok(GeneratedField::Path), - "size" => Ok(GeneratedField::Size), - "lastModifiedNs" | "last_modified_ns" => Ok(GeneratedField::LastModifiedNs), - "partitionValues" | "partition_values" => Ok(GeneratedField::PartitionValues), - "range" => Ok(GeneratedField::Range), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PartitionedFile; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PartitionedFile") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut path__ = None; - let mut size__ = None; - let mut last_modified_ns__ = None; - let mut partition_values__ = None; - let mut range__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Path => { - if path__.is_some() { - return Err(serde::de::Error::duplicate_field("path")); - } - path__ = Some(map.next_value()?); - } - GeneratedField::Size => { - if size__.is_some() { - return Err(serde::de::Error::duplicate_field("size")); - } - size__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::LastModifiedNs => { - if last_modified_ns__.is_some() { - return Err(serde::de::Error::duplicate_field("lastModifiedNs")); - } - last_modified_ns__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::PartitionValues => { - if partition_values__.is_some() { - return Err(serde::de::Error::duplicate_field("partitionValues")); - } - partition_values__ = Some(map.next_value()?); - } - GeneratedField::Range => { - if range__.is_some() { - return Err(serde::de::Error::duplicate_field("range")); - } - range__ = map.next_value()?; - } - } - } - Ok(PartitionedFile { - path: path__.unwrap_or_default(), - size: size__.unwrap_or_default(), - last_modified_ns: last_modified_ns__.unwrap_or_default(), - partition_values: partition_values__.unwrap_or_default(), - range: range__, - }) - } - } - deserializer.deserialize_struct("datafusion.PartitionedFile", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalAggregateExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.expr.is_empty() { - len += 1; - } - if !self.ordering_req.is_empty() { - len += 1; - } - if self.distinct { - len += 1; - } - if self.aggregate_function.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAggregateExprNode", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if !self.ordering_req.is_empty() { - struct_ser.serialize_field("orderingReq", &self.ordering_req)?; - } - if self.distinct { - struct_ser.serialize_field("distinct", &self.distinct)?; - } - if let Some(v) = self.aggregate_function.as_ref() { - match v { - physical_aggregate_expr_node::AggregateFunction::AggrFunction(v) => { - let v = AggregateFunction::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("aggrFunction", &v)?; - } - physical_aggregate_expr_node::AggregateFunction::UserDefinedAggrFunction(v) => { - struct_ser.serialize_field("userDefinedAggrFunction", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalAggregateExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "ordering_req", - "orderingReq", - "distinct", - "aggr_function", - "aggrFunction", - "user_defined_aggr_function", - "userDefinedAggrFunction", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - OrderingReq, - Distinct, - AggrFunction, - UserDefinedAggrFunction, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "orderingReq" | "ordering_req" => Ok(GeneratedField::OrderingReq), - "distinct" => Ok(GeneratedField::Distinct), - "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction), - "userDefinedAggrFunction" | "user_defined_aggr_function" => Ok(GeneratedField::UserDefinedAggrFunction), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalAggregateExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalAggregateExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut ordering_req__ = None; - let mut distinct__ = None; - let mut aggregate_function__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - GeneratedField::OrderingReq => { - if ordering_req__.is_some() { - return Err(serde::de::Error::duplicate_field("orderingReq")); - } - ordering_req__ = Some(map.next_value()?); - } - GeneratedField::Distinct => { - if distinct__.is_some() { - return Err(serde::de::Error::duplicate_field("distinct")); - } - distinct__ = Some(map.next_value()?); - } - GeneratedField::AggrFunction => { - if aggregate_function__.is_some() { - return Err(serde::de::Error::duplicate_field("aggrFunction")); - } - aggregate_function__ = map.next_value::<::std::option::Option>()?.map(|x| physical_aggregate_expr_node::AggregateFunction::AggrFunction(x as i32)); - } - GeneratedField::UserDefinedAggrFunction => { - if aggregate_function__.is_some() { - return Err(serde::de::Error::duplicate_field("userDefinedAggrFunction")); - } - aggregate_function__ = map.next_value::<::std::option::Option<_>>()?.map(physical_aggregate_expr_node::AggregateFunction::UserDefinedAggrFunction); - } - } - } - Ok(PhysicalAggregateExprNode { - expr: expr__.unwrap_or_default(), - ordering_req: ordering_req__.unwrap_or_default(), - distinct: distinct__.unwrap_or_default(), - aggregate_function: aggregate_function__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalAggregateExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalAliasNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if !self.alias.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalAliasNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if !self.alias.is_empty() { - struct_ser.serialize_field("alias", &self.alias)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalAliasNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "alias", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - Alias, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "alias" => Ok(GeneratedField::Alias), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalAliasNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalAliasNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut alias__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Alias => { - if alias__.is_some() { - return Err(serde::de::Error::duplicate_field("alias")); - } - alias__ = Some(map.next_value()?); - } - } - } - Ok(PhysicalAliasNode { - expr: expr__, - alias: alias__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalAliasNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalBinaryExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.l.is_some() { - len += 1; - } - if self.r.is_some() { - len += 1; - } - if !self.op.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalBinaryExprNode", len)?; - if let Some(v) = self.l.as_ref() { - struct_ser.serialize_field("l", v)?; - } - if let Some(v) = self.r.as_ref() { - struct_ser.serialize_field("r", v)?; - } - if !self.op.is_empty() { - struct_ser.serialize_field("op", &self.op)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalBinaryExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "l", - "r", - "op", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - L, - R, - Op, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "l" => Ok(GeneratedField::L), - "r" => Ok(GeneratedField::R), - "op" => Ok(GeneratedField::Op), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalBinaryExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalBinaryExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut l__ = None; - let mut r__ = None; - let mut op__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::L => { - if l__.is_some() { - return Err(serde::de::Error::duplicate_field("l")); - } - l__ = map.next_value()?; - } - GeneratedField::R => { - if r__.is_some() { - return Err(serde::de::Error::duplicate_field("r")); - } - r__ = map.next_value()?; - } - GeneratedField::Op => { - if op__.is_some() { - return Err(serde::de::Error::duplicate_field("op")); - } - op__ = Some(map.next_value()?); - } - } - } - Ok(PhysicalBinaryExprNode { - l: l__, - r: r__, - op: op__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalBinaryExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalCaseNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if !self.when_then_expr.is_empty() { - len += 1; - } - if self.else_expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCaseNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if !self.when_then_expr.is_empty() { - struct_ser.serialize_field("whenThenExpr", &self.when_then_expr)?; - } - if let Some(v) = self.else_expr.as_ref() { - struct_ser.serialize_field("elseExpr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalCaseNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "when_then_expr", - "whenThenExpr", - "else_expr", - "elseExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - WhenThenExpr, - ElseExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "whenThenExpr" | "when_then_expr" => Ok(GeneratedField::WhenThenExpr), - "elseExpr" | "else_expr" => Ok(GeneratedField::ElseExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalCaseNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalCaseNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut when_then_expr__ = None; - let mut else_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::WhenThenExpr => { - if when_then_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("whenThenExpr")); - } - when_then_expr__ = Some(map.next_value()?); - } - GeneratedField::ElseExpr => { - if else_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("elseExpr")); - } - else_expr__ = map.next_value()?; - } - } - } - Ok(PhysicalCaseNode { - expr: expr__, - when_then_expr: when_then_expr__.unwrap_or_default(), - else_expr: else_expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalCaseNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalCastNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.arrow_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalCastNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.arrow_type.as_ref() { - struct_ser.serialize_field("arrowType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalCastNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "arrow_type", - "arrowType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - ArrowType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalCastNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalCastNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut arrow_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::ArrowType => { - if arrow_type__.is_some() { - return Err(serde::de::Error::duplicate_field("arrowType")); - } - arrow_type__ = map.next_value()?; - } - } - } - Ok(PhysicalCastNode { - expr: expr__, - arrow_type: arrow_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalCastNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalColumn { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.index != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalColumn", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if self.index != 0 { - struct_ser.serialize_field("index", &self.index)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalColumn { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "index", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - Index, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "index" => Ok(GeneratedField::Index), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalColumn; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalColumn") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut index__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::Index => { - if index__.is_some() { - return Err(serde::de::Error::duplicate_field("index")); - } - index__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(PhysicalColumn { - name: name__.unwrap_or_default(), - index: index__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalColumn", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalDateTimeIntervalExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.l.is_some() { - len += 1; - } - if self.r.is_some() { - len += 1; - } - if !self.op.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", len)?; - if let Some(v) = self.l.as_ref() { - struct_ser.serialize_field("l", v)?; - } - if let Some(v) = self.r.as_ref() { - struct_ser.serialize_field("r", v)?; - } - if !self.op.is_empty() { - struct_ser.serialize_field("op", &self.op)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalDateTimeIntervalExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "l", - "r", - "op", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - L, - R, - Op, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "l" => Ok(GeneratedField::L), - "r" => Ok(GeneratedField::R), - "op" => Ok(GeneratedField::Op), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalDateTimeIntervalExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalDateTimeIntervalExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut l__ = None; - let mut r__ = None; - let mut op__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::L => { - if l__.is_some() { - return Err(serde::de::Error::duplicate_field("l")); - } - l__ = map.next_value()?; - } - GeneratedField::R => { - if r__.is_some() { - return Err(serde::de::Error::duplicate_field("r")); - } - r__ = map.next_value()?; - } - GeneratedField::Op => { - if op__.is_some() { - return Err(serde::de::Error::duplicate_field("op")); - } - op__ = Some(map.next_value()?); - } - } - } - Ok(PhysicalDateTimeIntervalExprNode { - l: l__, - r: r__, - op: op__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalDateTimeIntervalExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExprNode", len)?; - if let Some(v) = self.expr_type.as_ref() { - match v { - physical_expr_node::ExprType::Column(v) => { - struct_ser.serialize_field("column", v)?; - } - physical_expr_node::ExprType::Literal(v) => { - struct_ser.serialize_field("literal", v)?; - } - physical_expr_node::ExprType::BinaryExpr(v) => { - struct_ser.serialize_field("binaryExpr", v)?; - } - physical_expr_node::ExprType::AggregateExpr(v) => { - struct_ser.serialize_field("aggregateExpr", v)?; - } - physical_expr_node::ExprType::IsNullExpr(v) => { - struct_ser.serialize_field("isNullExpr", v)?; - } - physical_expr_node::ExprType::IsNotNullExpr(v) => { - struct_ser.serialize_field("isNotNullExpr", v)?; - } - physical_expr_node::ExprType::NotExpr(v) => { - struct_ser.serialize_field("notExpr", v)?; - } - physical_expr_node::ExprType::Case(v) => { - struct_ser.serialize_field("case", v)?; - } - physical_expr_node::ExprType::Cast(v) => { - struct_ser.serialize_field("cast", v)?; - } - physical_expr_node::ExprType::Sort(v) => { - struct_ser.serialize_field("sort", v)?; - } - physical_expr_node::ExprType::Negative(v) => { - struct_ser.serialize_field("negative", v)?; - } - physical_expr_node::ExprType::InList(v) => { - struct_ser.serialize_field("inList", v)?; - } - physical_expr_node::ExprType::ScalarFunction(v) => { - struct_ser.serialize_field("scalarFunction", v)?; - } - physical_expr_node::ExprType::TryCast(v) => { - struct_ser.serialize_field("tryCast", v)?; - } - physical_expr_node::ExprType::WindowExpr(v) => { - struct_ser.serialize_field("windowExpr", v)?; - } - physical_expr_node::ExprType::ScalarUdf(v) => { - struct_ser.serialize_field("scalarUdf", v)?; - } - physical_expr_node::ExprType::DateTimeIntervalExpr(v) => { - struct_ser.serialize_field("dateTimeIntervalExpr", v)?; - } - physical_expr_node::ExprType::LikeExpr(v) => { - struct_ser.serialize_field("likeExpr", v)?; - } - physical_expr_node::ExprType::GetIndexedFieldExpr(v) => { - struct_ser.serialize_field("getIndexedFieldExpr", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "column", - "literal", - "binary_expr", - "binaryExpr", - "aggregate_expr", - "aggregateExpr", - "is_null_expr", - "isNullExpr", - "is_not_null_expr", - "isNotNullExpr", - "not_expr", - "notExpr", - "case_", - "case", - "cast", - "sort", - "negative", - "in_list", - "inList", - "scalar_function", - "scalarFunction", - "try_cast", - "tryCast", - "window_expr", - "windowExpr", - "scalar_udf", - "scalarUdf", - "date_time_interval_expr", - "dateTimeIntervalExpr", - "like_expr", - "likeExpr", - "get_indexed_field_expr", - "getIndexedFieldExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Column, - Literal, - BinaryExpr, - AggregateExpr, - IsNullExpr, - IsNotNullExpr, - NotExpr, - Case, - Cast, - Sort, - Negative, - InList, - ScalarFunction, - TryCast, - WindowExpr, - ScalarUdf, - DateTimeIntervalExpr, - LikeExpr, - GetIndexedFieldExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "column" => Ok(GeneratedField::Column), - "literal" => Ok(GeneratedField::Literal), - "binaryExpr" | "binary_expr" => Ok(GeneratedField::BinaryExpr), - "aggregateExpr" | "aggregate_expr" => Ok(GeneratedField::AggregateExpr), - "isNullExpr" | "is_null_expr" => Ok(GeneratedField::IsNullExpr), - "isNotNullExpr" | "is_not_null_expr" => Ok(GeneratedField::IsNotNullExpr), - "notExpr" | "not_expr" => Ok(GeneratedField::NotExpr), - "case" | "case_" => Ok(GeneratedField::Case), - "cast" => Ok(GeneratedField::Cast), - "sort" => Ok(GeneratedField::Sort), - "negative" => Ok(GeneratedField::Negative), - "inList" | "in_list" => Ok(GeneratedField::InList), - "scalarFunction" | "scalar_function" => Ok(GeneratedField::ScalarFunction), - "tryCast" | "try_cast" => Ok(GeneratedField::TryCast), - "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), - "scalarUdf" | "scalar_udf" => Ok(GeneratedField::ScalarUdf), - "dateTimeIntervalExpr" | "date_time_interval_expr" => Ok(GeneratedField::DateTimeIntervalExpr), - "likeExpr" | "like_expr" => Ok(GeneratedField::LikeExpr), - "getIndexedFieldExpr" | "get_indexed_field_expr" => Ok(GeneratedField::GetIndexedFieldExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Column => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("column")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Column) -; - } - GeneratedField::Literal => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("literal")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Literal) -; - } - GeneratedField::BinaryExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("binaryExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::BinaryExpr) -; - } - GeneratedField::AggregateExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregateExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::AggregateExpr) -; - } - GeneratedField::IsNullExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNullExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNullExpr) -; - } - GeneratedField::IsNotNullExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("isNotNullExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::IsNotNullExpr) -; - } - GeneratedField::NotExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("notExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::NotExpr) -; - } - GeneratedField::Case => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("case")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Case) -; - } - GeneratedField::Cast => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("cast")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Cast) -; - } - GeneratedField::Sort => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("sort")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Sort) -; - } - GeneratedField::Negative => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("negative")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::Negative) -; - } - GeneratedField::InList => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("inList")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::InList) -; - } - GeneratedField::ScalarFunction => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("scalarFunction")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarFunction) -; - } - GeneratedField::TryCast => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("tryCast")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::TryCast) -; - } - GeneratedField::WindowExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("windowExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::WindowExpr) -; - } - GeneratedField::ScalarUdf => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("scalarUdf")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::ScalarUdf) -; - } - GeneratedField::DateTimeIntervalExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("dateTimeIntervalExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::DateTimeIntervalExpr) -; - } - GeneratedField::LikeExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("likeExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::LikeExpr) -; - } - GeneratedField::GetIndexedFieldExpr => { - if expr_type__.is_some() { - return Err(serde::de::Error::duplicate_field("getIndexedFieldExpr")); - } - expr_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_expr_node::ExprType::GetIndexedFieldExpr) -; - } - } - } - Ok(PhysicalExprNode { - expr_type: expr_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalExtensionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.node.is_empty() { - len += 1; - } - if !self.inputs.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalExtensionNode", len)?; - if !self.node.is_empty() { - struct_ser.serialize_field("node", pbjson::private::base64::encode(&self.node).as_str())?; - } - if !self.inputs.is_empty() { - struct_ser.serialize_field("inputs", &self.inputs)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalExtensionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "node", - "inputs", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Node, - Inputs, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "node" => Ok(GeneratedField::Node), - "inputs" => Ok(GeneratedField::Inputs), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalExtensionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalExtensionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut node__ = None; - let mut inputs__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Node => { - if node__.is_some() { - return Err(serde::de::Error::duplicate_field("node")); - } - node__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Inputs => { - if inputs__.is_some() { - return Err(serde::de::Error::duplicate_field("inputs")); - } - inputs__ = Some(map.next_value()?); - } - } - } - Ok(PhysicalExtensionNode { - node: node__.unwrap_or_default(), - inputs: inputs__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalExtensionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalGetIndexedFieldExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.arg.is_some() { - len += 1; - } - if self.key.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalGetIndexedFieldExprNode", len)?; - if let Some(v) = self.arg.as_ref() { - struct_ser.serialize_field("arg", v)?; - } - if let Some(v) = self.key.as_ref() { - struct_ser.serialize_field("key", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalGetIndexedFieldExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "arg", - "key", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Arg, - Key, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "arg" => Ok(GeneratedField::Arg), - "key" => Ok(GeneratedField::Key), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalGetIndexedFieldExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalGetIndexedFieldExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut arg__ = None; - let mut key__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Arg => { - if arg__.is_some() { - return Err(serde::de::Error::duplicate_field("arg")); - } - arg__ = map.next_value()?; - } - GeneratedField::Key => { - if key__.is_some() { - return Err(serde::de::Error::duplicate_field("key")); - } - key__ = map.next_value()?; - } - } - } - Ok(PhysicalGetIndexedFieldExprNode { - arg: arg__, - key: key__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalGetIndexedFieldExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalHashRepartition { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.hash_expr.is_empty() { - len += 1; - } - if self.partition_count != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalHashRepartition", len)?; - if !self.hash_expr.is_empty() { - struct_ser.serialize_field("hashExpr", &self.hash_expr)?; - } - if self.partition_count != 0 { - struct_ser.serialize_field("partitionCount", ToString::to_string(&self.partition_count).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalHashRepartition { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "hash_expr", - "hashExpr", - "partition_count", - "partitionCount", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - HashExpr, - PartitionCount, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "hashExpr" | "hash_expr" => Ok(GeneratedField::HashExpr), - "partitionCount" | "partition_count" => Ok(GeneratedField::PartitionCount), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalHashRepartition; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalHashRepartition") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut hash_expr__ = None; - let mut partition_count__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::HashExpr => { - if hash_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("hashExpr")); - } - hash_expr__ = Some(map.next_value()?); - } - GeneratedField::PartitionCount => { - if partition_count__.is_some() { - return Err(serde::de::Error::duplicate_field("partitionCount")); - } - partition_count__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(PhysicalHashRepartition { - hash_expr: hash_expr__.unwrap_or_default(), - partition_count: partition_count__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalHashRepartition", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalInListNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if !self.list.is_empty() { - len += 1; - } - if self.negated { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalInListNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if !self.list.is_empty() { - struct_ser.serialize_field("list", &self.list)?; - } - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalInListNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "list", - "negated", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - List, - Negated, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "list" => Ok(GeneratedField::List), - "negated" => Ok(GeneratedField::Negated), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalInListNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalInListNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut list__ = None; - let mut negated__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::List => { - if list__.is_some() { - return Err(serde::de::Error::duplicate_field("list")); - } - list__ = Some(map.next_value()?); - } - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); - } - negated__ = Some(map.next_value()?); - } - } - } - Ok(PhysicalInListNode { - expr: expr__, - list: list__.unwrap_or_default(), - negated: negated__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalInListNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalIsNotNull { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNotNull", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalIsNotNull { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalIsNotNull; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalIsNotNull") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(PhysicalIsNotNull { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalIsNotNull", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalIsNull { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalIsNull", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalIsNull { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalIsNull; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalIsNull") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(PhysicalIsNull { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalIsNull", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalLikeExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.negated { - len += 1; - } - if self.case_insensitive { - len += 1; - } - if self.expr.is_some() { - len += 1; - } - if self.pattern.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalLikeExprNode", len)?; - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - if self.case_insensitive { - struct_ser.serialize_field("caseInsensitive", &self.case_insensitive)?; - } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.pattern.as_ref() { - struct_ser.serialize_field("pattern", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalLikeExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "negated", - "case_insensitive", - "caseInsensitive", - "expr", - "pattern", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Negated, - CaseInsensitive, - Expr, - Pattern, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "negated" => Ok(GeneratedField::Negated), - "caseInsensitive" | "case_insensitive" => Ok(GeneratedField::CaseInsensitive), - "expr" => Ok(GeneratedField::Expr), - "pattern" => Ok(GeneratedField::Pattern), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalLikeExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalLikeExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut negated__ = None; - let mut case_insensitive__ = None; - let mut expr__ = None; - let mut pattern__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); - } - negated__ = Some(map.next_value()?); - } - GeneratedField::CaseInsensitive => { - if case_insensitive__.is_some() { - return Err(serde::de::Error::duplicate_field("caseInsensitive")); - } - case_insensitive__ = Some(map.next_value()?); - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Pattern => { - if pattern__.is_some() { - return Err(serde::de::Error::duplicate_field("pattern")); - } - pattern__ = map.next_value()?; - } - } - } - Ok(PhysicalLikeExprNode { - negated: negated__.unwrap_or_default(), - case_insensitive: case_insensitive__.unwrap_or_default(), - expr: expr__, - pattern: pattern__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalLikeExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalNegativeNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNegativeNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalNegativeNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalNegativeNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalNegativeNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(PhysicalNegativeNode { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalNegativeNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalNot { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalNot", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalNot { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalNot; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalNot") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(PhysicalNot { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalNot", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalPlanNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.physical_plan_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalPlanNode", len)?; - if let Some(v) = self.physical_plan_type.as_ref() { - match v { - physical_plan_node::PhysicalPlanType::ParquetScan(v) => { - struct_ser.serialize_field("parquetScan", v)?; - } - physical_plan_node::PhysicalPlanType::CsvScan(v) => { - struct_ser.serialize_field("csvScan", v)?; - } - physical_plan_node::PhysicalPlanType::Empty(v) => { - struct_ser.serialize_field("empty", v)?; - } - physical_plan_node::PhysicalPlanType::Projection(v) => { - struct_ser.serialize_field("projection", v)?; - } - physical_plan_node::PhysicalPlanType::GlobalLimit(v) => { - struct_ser.serialize_field("globalLimit", v)?; - } - physical_plan_node::PhysicalPlanType::LocalLimit(v) => { - struct_ser.serialize_field("localLimit", v)?; - } - physical_plan_node::PhysicalPlanType::Aggregate(v) => { - struct_ser.serialize_field("aggregate", v)?; - } - physical_plan_node::PhysicalPlanType::HashJoin(v) => { - struct_ser.serialize_field("hashJoin", v)?; - } - physical_plan_node::PhysicalPlanType::Sort(v) => { - struct_ser.serialize_field("sort", v)?; - } - physical_plan_node::PhysicalPlanType::CoalesceBatches(v) => { - struct_ser.serialize_field("coalesceBatches", v)?; - } - physical_plan_node::PhysicalPlanType::Filter(v) => { - struct_ser.serialize_field("filter", v)?; - } - physical_plan_node::PhysicalPlanType::Merge(v) => { - struct_ser.serialize_field("merge", v)?; - } - physical_plan_node::PhysicalPlanType::Repartition(v) => { - struct_ser.serialize_field("repartition", v)?; - } - physical_plan_node::PhysicalPlanType::Window(v) => { - struct_ser.serialize_field("window", v)?; - } - physical_plan_node::PhysicalPlanType::CrossJoin(v) => { - struct_ser.serialize_field("crossJoin", v)?; - } - physical_plan_node::PhysicalPlanType::AvroScan(v) => { - struct_ser.serialize_field("avroScan", v)?; - } - physical_plan_node::PhysicalPlanType::Extension(v) => { - struct_ser.serialize_field("extension", v)?; - } - physical_plan_node::PhysicalPlanType::Union(v) => { - struct_ser.serialize_field("union", v)?; - } - physical_plan_node::PhysicalPlanType::Explain(v) => { - struct_ser.serialize_field("explain", v)?; - } - physical_plan_node::PhysicalPlanType::SortPreservingMerge(v) => { - struct_ser.serialize_field("sortPreservingMerge", v)?; - } - physical_plan_node::PhysicalPlanType::NestedLoopJoin(v) => { - struct_ser.serialize_field("nestedLoopJoin", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalPlanNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "parquet_scan", - "parquetScan", - "csv_scan", - "csvScan", - "empty", - "projection", - "global_limit", - "globalLimit", - "local_limit", - "localLimit", - "aggregate", - "hash_join", - "hashJoin", - "sort", - "coalesce_batches", - "coalesceBatches", - "filter", - "merge", - "repartition", - "window", - "cross_join", - "crossJoin", - "avro_scan", - "avroScan", - "extension", - "union", - "explain", - "sort_preserving_merge", - "sortPreservingMerge", - "nested_loop_join", - "nestedLoopJoin", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - ParquetScan, - CsvScan, - Empty, - Projection, - GlobalLimit, - LocalLimit, - Aggregate, - HashJoin, - Sort, - CoalesceBatches, - Filter, - Merge, - Repartition, - Window, - CrossJoin, - AvroScan, - Extension, - Union, - Explain, - SortPreservingMerge, - NestedLoopJoin, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "parquetScan" | "parquet_scan" => Ok(GeneratedField::ParquetScan), - "csvScan" | "csv_scan" => Ok(GeneratedField::CsvScan), - "empty" => Ok(GeneratedField::Empty), - "projection" => Ok(GeneratedField::Projection), - "globalLimit" | "global_limit" => Ok(GeneratedField::GlobalLimit), - "localLimit" | "local_limit" => Ok(GeneratedField::LocalLimit), - "aggregate" => Ok(GeneratedField::Aggregate), - "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin), - "sort" => Ok(GeneratedField::Sort), - "coalesceBatches" | "coalesce_batches" => Ok(GeneratedField::CoalesceBatches), - "filter" => Ok(GeneratedField::Filter), - "merge" => Ok(GeneratedField::Merge), - "repartition" => Ok(GeneratedField::Repartition), - "window" => Ok(GeneratedField::Window), - "crossJoin" | "cross_join" => Ok(GeneratedField::CrossJoin), - "avroScan" | "avro_scan" => Ok(GeneratedField::AvroScan), - "extension" => Ok(GeneratedField::Extension), - "union" => Ok(GeneratedField::Union), - "explain" => Ok(GeneratedField::Explain), - "sortPreservingMerge" | "sort_preserving_merge" => Ok(GeneratedField::SortPreservingMerge), - "nestedLoopJoin" | "nested_loop_join" => Ok(GeneratedField::NestedLoopJoin), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalPlanNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalPlanNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut physical_plan_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::ParquetScan => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("parquetScan")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::ParquetScan) -; - } - GeneratedField::CsvScan => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("csvScan")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CsvScan) -; - } - GeneratedField::Empty => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("empty")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Empty) -; - } - GeneratedField::Projection => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Projection) -; - } - GeneratedField::GlobalLimit => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("globalLimit")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::GlobalLimit) -; - } - GeneratedField::LocalLimit => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("localLimit")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::LocalLimit) -; - } - GeneratedField::Aggregate => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("aggregate")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Aggregate) -; - } - GeneratedField::HashJoin => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("hashJoin")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::HashJoin) -; - } - GeneratedField::Sort => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("sort")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Sort) -; - } - GeneratedField::CoalesceBatches => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("coalesceBatches")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CoalesceBatches) -; - } - GeneratedField::Filter => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("filter")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Filter) -; - } - GeneratedField::Merge => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("merge")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Merge) -; - } - GeneratedField::Repartition => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("repartition")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Repartition) -; - } - GeneratedField::Window => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("window")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Window) -; - } - GeneratedField::CrossJoin => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("crossJoin")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::CrossJoin) -; - } - GeneratedField::AvroScan => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("avroScan")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::AvroScan) -; - } - GeneratedField::Extension => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("extension")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Extension) -; - } - GeneratedField::Union => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("union")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Union) -; - } - GeneratedField::Explain => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("explain")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::Explain) -; - } - GeneratedField::SortPreservingMerge => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("sortPreservingMerge")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::SortPreservingMerge) -; - } - GeneratedField::NestedLoopJoin => { - if physical_plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("nestedLoopJoin")); - } - physical_plan_type__ = map.next_value::<::std::option::Option<_>>()?.map(physical_plan_node::PhysicalPlanType::NestedLoopJoin) -; - } - } - } - Ok(PhysicalPlanNode { - physical_plan_type: physical_plan_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalPlanNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalScalarFunctionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if self.fun != 0 { - len += 1; - } - if !self.args.is_empty() { - len += 1; - } - if self.return_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarFunctionNode", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if self.fun != 0 { - let v = ScalarFunction::from_i32(self.fun) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?; - struct_ser.serialize_field("fun", &v)?; - } - if !self.args.is_empty() { - struct_ser.serialize_field("args", &self.args)?; - } - if let Some(v) = self.return_type.as_ref() { - struct_ser.serialize_field("returnType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalScalarFunctionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "fun", - "args", - "return_type", - "returnType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - Fun, - Args, - ReturnType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "fun" => Ok(GeneratedField::Fun), - "args" => Ok(GeneratedField::Args), - "returnType" | "return_type" => Ok(GeneratedField::ReturnType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalScalarFunctionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalScalarFunctionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut fun__ = None; - let mut args__ = None; - let mut return_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::Fun => { - if fun__.is_some() { - return Err(serde::de::Error::duplicate_field("fun")); - } - fun__ = Some(map.next_value::()? as i32); - } - GeneratedField::Args => { - if args__.is_some() { - return Err(serde::de::Error::duplicate_field("args")); - } - args__ = Some(map.next_value()?); - } - GeneratedField::ReturnType => { - if return_type__.is_some() { - return Err(serde::de::Error::duplicate_field("returnType")); - } - return_type__ = map.next_value()?; - } - } - } - Ok(PhysicalScalarFunctionNode { - name: name__.unwrap_or_default(), - fun: fun__.unwrap_or_default(), - args: args__.unwrap_or_default(), - return_type: return_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalScalarFunctionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalScalarUdfNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if !self.args.is_empty() { - len += 1; - } - if self.return_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalScalarUdfNode", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if !self.args.is_empty() { - struct_ser.serialize_field("args", &self.args)?; - } - if let Some(v) = self.return_type.as_ref() { - struct_ser.serialize_field("returnType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalScalarUdfNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "args", - "return_type", - "returnType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - Args, - ReturnType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "args" => Ok(GeneratedField::Args), - "returnType" | "return_type" => Ok(GeneratedField::ReturnType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalScalarUdfNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalScalarUdfNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut args__ = None; - let mut return_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::Args => { - if args__.is_some() { - return Err(serde::de::Error::duplicate_field("args")); - } - args__ = Some(map.next_value()?); - } - GeneratedField::ReturnType => { - if return_type__.is_some() { - return Err(serde::de::Error::duplicate_field("returnType")); - } - return_type__ = map.next_value()?; - } - } - } - Ok(PhysicalScalarUdfNode { - name: name__.unwrap_or_default(), - args: args__.unwrap_or_default(), - return_type: return_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalScalarUdfNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalSortExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.asc { - len += 1; - } - if self.nulls_first { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalSortExprNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if self.asc { - struct_ser.serialize_field("asc", &self.asc)?; - } - if self.nulls_first { - struct_ser.serialize_field("nullsFirst", &self.nulls_first)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalSortExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "asc", - "nulls_first", - "nullsFirst", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - Asc, - NullsFirst, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "asc" => Ok(GeneratedField::Asc), - "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalSortExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalSortExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut asc__ = None; - let mut nulls_first__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Asc => { - if asc__.is_some() { - return Err(serde::de::Error::duplicate_field("asc")); - } - asc__ = Some(map.next_value()?); - } - GeneratedField::NullsFirst => { - if nulls_first__.is_some() { - return Err(serde::de::Error::duplicate_field("nullsFirst")); - } - nulls_first__ = Some(map.next_value()?); - } - } - } - Ok(PhysicalSortExprNode { - expr: expr__, - asc: asc__.unwrap_or_default(), - nulls_first: nulls_first__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalSortExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalSortExprNodeCollection { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.physical_sort_expr_nodes.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalSortExprNodeCollection", len)?; - if !self.physical_sort_expr_nodes.is_empty() { - struct_ser.serialize_field("physicalSortExprNodes", &self.physical_sort_expr_nodes)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalSortExprNodeCollection { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "physical_sort_expr_nodes", - "physicalSortExprNodes", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - PhysicalSortExprNodes, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "physicalSortExprNodes" | "physical_sort_expr_nodes" => Ok(GeneratedField::PhysicalSortExprNodes), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalSortExprNodeCollection; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalSortExprNodeCollection") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut physical_sort_expr_nodes__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::PhysicalSortExprNodes => { - if physical_sort_expr_nodes__.is_some() { - return Err(serde::de::Error::duplicate_field("physicalSortExprNodes")); - } - physical_sort_expr_nodes__ = Some(map.next_value()?); - } - } - } - Ok(PhysicalSortExprNodeCollection { - physical_sort_expr_nodes: physical_sort_expr_nodes__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalSortExprNodeCollection", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalTryCastNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.arrow_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalTryCastNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.arrow_type.as_ref() { - struct_ser.serialize_field("arrowType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalTryCastNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "arrow_type", - "arrowType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - ArrowType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalTryCastNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalTryCastNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut arrow_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::ArrowType => { - if arrow_type__.is_some() { - return Err(serde::de::Error::duplicate_field("arrowType")); - } - arrow_type__ = map.next_value()?; - } - } - } - Ok(PhysicalTryCastNode { - expr: expr__, - arrow_type: arrow_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalTryCastNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalWhenThen { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.when_expr.is_some() { - len += 1; - } - if self.then_expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWhenThen", len)?; - if let Some(v) = self.when_expr.as_ref() { - struct_ser.serialize_field("whenExpr", v)?; - } - if let Some(v) = self.then_expr.as_ref() { - struct_ser.serialize_field("thenExpr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalWhenThen { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "when_expr", - "whenExpr", - "then_expr", - "thenExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - WhenExpr, - ThenExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr), - "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalWhenThen; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalWhenThen") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut when_expr__ = None; - let mut then_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::WhenExpr => { - if when_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("whenExpr")); - } - when_expr__ = map.next_value()?; - } - GeneratedField::ThenExpr => { - if then_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("thenExpr")); - } - then_expr__ = map.next_value()?; - } - } - } - Ok(PhysicalWhenThen { - when_expr: when_expr__, - then_expr: then_expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalWhenThen", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PhysicalWindowExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.window_function.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PhysicalWindowExprNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.window_function.as_ref() { - match v { - physical_window_expr_node::WindowFunction::AggrFunction(v) => { - let v = AggregateFunction::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("aggrFunction", &v)?; - } - physical_window_expr_node::WindowFunction::BuiltInFunction(v) => { - let v = BuiltInWindowFunction::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("builtInFunction", &v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PhysicalWindowExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "aggr_function", - "aggrFunction", - "built_in_function", - "builtInFunction", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - AggrFunction, - BuiltInFunction, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction), - "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PhysicalWindowExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PhysicalWindowExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut window_function__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::AggrFunction => { - if window_function__.is_some() { - return Err(serde::de::Error::duplicate_field("aggrFunction")); - } - window_function__ = map.next_value::<::std::option::Option>()?.map(|x| physical_window_expr_node::WindowFunction::AggrFunction(x as i32)); - } - GeneratedField::BuiltInFunction => { - if window_function__.is_some() { - return Err(serde::de::Error::duplicate_field("builtInFunction")); - } - window_function__ = map.next_value::<::std::option::Option>()?.map(|x| physical_window_expr_node::WindowFunction::BuiltInFunction(x as i32)); - } - } - } - Ok(PhysicalWindowExprNode { - expr: expr__, - window_function: window_function__, - }) - } - } - deserializer.deserialize_struct("datafusion.PhysicalWindowExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PlaceholderNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.id.is_empty() { - len += 1; - } - if self.data_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PlaceholderNode", len)?; - if !self.id.is_empty() { - struct_ser.serialize_field("id", &self.id)?; - } - if let Some(v) = self.data_type.as_ref() { - struct_ser.serialize_field("dataType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PlaceholderNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "id", - "data_type", - "dataType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Id, - DataType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "id" => Ok(GeneratedField::Id), - "dataType" | "data_type" => Ok(GeneratedField::DataType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PlaceholderNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PlaceholderNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut id__ = None; - let mut data_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Id => { - if id__.is_some() { - return Err(serde::de::Error::duplicate_field("id")); - } - id__ = Some(map.next_value()?); - } - GeneratedField::DataType => { - if data_type__.is_some() { - return Err(serde::de::Error::duplicate_field("dataType")); - } - data_type__ = map.next_value()?; - } - } - } - Ok(PlaceholderNode { - id: id__.unwrap_or_default(), - data_type: data_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.PlaceholderNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PlanType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.plan_type_enum.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PlanType", len)?; - if let Some(v) = self.plan_type_enum.as_ref() { - match v { - plan_type::PlanTypeEnum::InitialLogicalPlan(v) => { - struct_ser.serialize_field("InitialLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::AnalyzedLogicalPlan(v) => { - struct_ser.serialize_field("AnalyzedLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::FinalAnalyzedLogicalPlan(v) => { - struct_ser.serialize_field("FinalAnalyzedLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::OptimizedLogicalPlan(v) => { - struct_ser.serialize_field("OptimizedLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::FinalLogicalPlan(v) => { - struct_ser.serialize_field("FinalLogicalPlan", v)?; - } - plan_type::PlanTypeEnum::InitialPhysicalPlan(v) => { - struct_ser.serialize_field("InitialPhysicalPlan", v)?; - } - plan_type::PlanTypeEnum::OptimizedPhysicalPlan(v) => { - struct_ser.serialize_field("OptimizedPhysicalPlan", v)?; - } - plan_type::PlanTypeEnum::FinalPhysicalPlan(v) => { - struct_ser.serialize_field("FinalPhysicalPlan", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PlanType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "InitialLogicalPlan", - "AnalyzedLogicalPlan", - "FinalAnalyzedLogicalPlan", - "OptimizedLogicalPlan", - "FinalLogicalPlan", - "InitialPhysicalPlan", - "OptimizedPhysicalPlan", - "FinalPhysicalPlan", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - InitialLogicalPlan, - AnalyzedLogicalPlan, - FinalAnalyzedLogicalPlan, - OptimizedLogicalPlan, - FinalLogicalPlan, - InitialPhysicalPlan, - OptimizedPhysicalPlan, - FinalPhysicalPlan, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "InitialLogicalPlan" => Ok(GeneratedField::InitialLogicalPlan), - "AnalyzedLogicalPlan" => Ok(GeneratedField::AnalyzedLogicalPlan), - "FinalAnalyzedLogicalPlan" => Ok(GeneratedField::FinalAnalyzedLogicalPlan), - "OptimizedLogicalPlan" => Ok(GeneratedField::OptimizedLogicalPlan), - "FinalLogicalPlan" => Ok(GeneratedField::FinalLogicalPlan), - "InitialPhysicalPlan" => Ok(GeneratedField::InitialPhysicalPlan), - "OptimizedPhysicalPlan" => Ok(GeneratedField::OptimizedPhysicalPlan), - "FinalPhysicalPlan" => Ok(GeneratedField::FinalPhysicalPlan), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PlanType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PlanType") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut plan_type_enum__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::InitialLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("InitialLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialLogicalPlan) -; - } - GeneratedField::AnalyzedLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("AnalyzedLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::AnalyzedLogicalPlan) -; - } - GeneratedField::FinalAnalyzedLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FinalAnalyzedLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalAnalyzedLogicalPlan) -; - } - GeneratedField::OptimizedLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("OptimizedLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedLogicalPlan) -; - } - GeneratedField::FinalLogicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FinalLogicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalLogicalPlan) -; - } - GeneratedField::InitialPhysicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("InitialPhysicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::InitialPhysicalPlan) -; - } - GeneratedField::OptimizedPhysicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("OptimizedPhysicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::OptimizedPhysicalPlan) -; - } - GeneratedField::FinalPhysicalPlan => { - if plan_type_enum__.is_some() { - return Err(serde::de::Error::duplicate_field("FinalPhysicalPlan")); - } - plan_type_enum__ = map.next_value::<::std::option::Option<_>>()?.map(plan_type::PlanTypeEnum::FinalPhysicalPlan) -; - } - } - } - Ok(PlanType { - plan_type_enum: plan_type_enum__, - }) - } - } - deserializer.deserialize_struct("datafusion.PlanType", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for PrepareNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.name.is_empty() { - len += 1; - } - if !self.data_types.is_empty() { - len += 1; - } - if self.input.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.PrepareNode", len)?; - if !self.name.is_empty() { - struct_ser.serialize_field("name", &self.name)?; - } - if !self.data_types.is_empty() { - struct_ser.serialize_field("dataTypes", &self.data_types)?; - } - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for PrepareNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "name", - "data_types", - "dataTypes", - "input", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Name, - DataTypes, - Input, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "name" => Ok(GeneratedField::Name), - "dataTypes" | "data_types" => Ok(GeneratedField::DataTypes), - "input" => Ok(GeneratedField::Input), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = PrepareNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.PrepareNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut name__ = None; - let mut data_types__ = None; - let mut input__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Name => { - if name__.is_some() { - return Err(serde::de::Error::duplicate_field("name")); - } - name__ = Some(map.next_value()?); - } - GeneratedField::DataTypes => { - if data_types__.is_some() { - return Err(serde::de::Error::duplicate_field("dataTypes")); - } - data_types__ = Some(map.next_value()?); - } - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - } - } - Ok(PrepareNode { - name: name__.unwrap_or_default(), - data_types: data_types__.unwrap_or_default(), - input: input__, - }) - } - } - deserializer.deserialize_struct("datafusion.PrepareNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ProjectionColumns { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.columns.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionColumns", len)?; - if !self.columns.is_empty() { - struct_ser.serialize_field("columns", &self.columns)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ProjectionColumns { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "columns", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Columns, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "columns" => Ok(GeneratedField::Columns), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProjectionColumns; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ProjectionColumns") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut columns__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Columns => { - if columns__.is_some() { - return Err(serde::de::Error::duplicate_field("columns")); - } - columns__ = Some(map.next_value()?); - } - } - } - Ok(ProjectionColumns { - columns: columns__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ProjectionColumns", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ProjectionExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.expr.is_empty() { - len += 1; - } - if !self.expr_name.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if !self.expr_name.is_empty() { - struct_ser.serialize_field("exprName", &self.expr_name)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ProjectionExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "expr", - "expr_name", - "exprName", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Expr, - ExprName, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - "exprName" | "expr_name" => Ok(GeneratedField::ExprName), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProjectionExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ProjectionExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut expr__ = None; - let mut expr_name__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - GeneratedField::ExprName => { - if expr_name__.is_some() { - return Err(serde::de::Error::duplicate_field("exprName")); - } - expr_name__ = Some(map.next_value()?); - } - } - } - Ok(ProjectionExecNode { - input: input__, - expr: expr__.unwrap_or_default(), - expr_name: expr_name__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ProjectionExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ProjectionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.expr.is_empty() { - len += 1; - } - if self.optional_alias.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ProjectionNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if let Some(v) = self.optional_alias.as_ref() { - match v { - projection_node::OptionalAlias::Alias(v) => { - struct_ser.serialize_field("alias", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ProjectionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "expr", - "alias", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Expr, - Alias, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - "alias" => Ok(GeneratedField::Alias), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ProjectionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ProjectionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut expr__ = None; - let mut optional_alias__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - GeneratedField::Alias => { - if optional_alias__.is_some() { - return Err(serde::de::Error::duplicate_field("alias")); - } - optional_alias__ = map.next_value::<::std::option::Option<_>>()?.map(projection_node::OptionalAlias::Alias); - } - } - } - Ok(ProjectionNode { - input: input__, - expr: expr__.unwrap_or_default(), - optional_alias: optional_alias__, - }) - } - } - deserializer.deserialize_struct("datafusion.ProjectionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for RepartitionExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.partition_method.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.partition_method.as_ref() { - match v { - repartition_exec_node::PartitionMethod::RoundRobin(v) => { - struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?; - } - repartition_exec_node::PartitionMethod::Hash(v) => { - struct_ser.serialize_field("hash", v)?; - } - repartition_exec_node::PartitionMethod::Unknown(v) => { - struct_ser.serialize_field("unknown", ToString::to_string(&v).as_str())?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for RepartitionExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "round_robin", - "roundRobin", - "hash", - "unknown", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - RoundRobin, - Hash, - Unknown, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin), - "hash" => Ok(GeneratedField::Hash), - "unknown" => Ok(GeneratedField::Unknown), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = RepartitionExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.RepartitionExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut partition_method__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::RoundRobin => { - if partition_method__.is_some() { - return Err(serde::de::Error::duplicate_field("roundRobin")); - } - partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::RoundRobin(x.0)); - } - GeneratedField::Hash => { - if partition_method__.is_some() { - return Err(serde::de::Error::duplicate_field("hash")); - } - partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_exec_node::PartitionMethod::Hash) -; - } - GeneratedField::Unknown => { - if partition_method__.is_some() { - return Err(serde::de::Error::duplicate_field("unknown")); - } - partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_exec_node::PartitionMethod::Unknown(x.0)); - } - } - } - Ok(RepartitionExecNode { - input: input__, - partition_method: partition_method__, - }) - } - } - deserializer.deserialize_struct("datafusion.RepartitionExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for RepartitionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.partition_method.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.RepartitionNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.partition_method.as_ref() { - match v { - repartition_node::PartitionMethod::RoundRobin(v) => { - struct_ser.serialize_field("roundRobin", ToString::to_string(&v).as_str())?; - } - repartition_node::PartitionMethod::Hash(v) => { - struct_ser.serialize_field("hash", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for RepartitionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "round_robin", - "roundRobin", - "hash", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - RoundRobin, - Hash, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "roundRobin" | "round_robin" => Ok(GeneratedField::RoundRobin), - "hash" => Ok(GeneratedField::Hash), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = RepartitionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.RepartitionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut partition_method__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::RoundRobin => { - if partition_method__.is_some() { - return Err(serde::de::Error::duplicate_field("roundRobin")); - } - partition_method__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| repartition_node::PartitionMethod::RoundRobin(x.0)); - } - GeneratedField::Hash => { - if partition_method__.is_some() { - return Err(serde::de::Error::duplicate_field("hash")); - } - partition_method__ = map.next_value::<::std::option::Option<_>>()?.map(repartition_node::PartitionMethod::Hash) -; - } - } - } - Ok(RepartitionNode { - input: input__, - partition_method: partition_method__, - }) - } - } - deserializer.deserialize_struct("datafusion.RepartitionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for RollupNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.RollupNode", len)?; - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for RollupNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = RollupNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.RollupNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - } - } - Ok(RollupNode { - expr: expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.RollupNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarDictionaryValue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.index_type.is_some() { - len += 1; - } - if self.value.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarDictionaryValue", len)?; - if let Some(v) = self.index_type.as_ref() { - struct_ser.serialize_field("indexType", v)?; - } - if let Some(v) = self.value.as_ref() { - struct_ser.serialize_field("value", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarDictionaryValue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "index_type", - "indexType", - "value", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - IndexType, - Value, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "indexType" | "index_type" => Ok(GeneratedField::IndexType), - "value" => Ok(GeneratedField::Value), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarDictionaryValue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarDictionaryValue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut index_type__ = None; - let mut value__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::IndexType => { - if index_type__.is_some() { - return Err(serde::de::Error::duplicate_field("indexType")); - } - index_type__ = map.next_value()?; - } - GeneratedField::Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("value")); - } - value__ = map.next_value()?; - } - } - } - Ok(ScalarDictionaryValue { - index_type: index_type__, - value: value__, - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarDictionaryValue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarFixedSizeBinary { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.values.is_empty() { - len += 1; - } - if self.length != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFixedSizeBinary", len)?; - if !self.values.is_empty() { - struct_ser.serialize_field("values", pbjson::private::base64::encode(&self.values).as_str())?; - } - if self.length != 0 { - struct_ser.serialize_field("length", &self.length)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarFixedSizeBinary { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "values", - "length", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Values, - Length, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "values" => Ok(GeneratedField::Values), - "length" => Ok(GeneratedField::Length), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarFixedSizeBinary; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarFixedSizeBinary") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut values__ = None; - let mut length__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Values => { - if values__.is_some() { - return Err(serde::de::Error::duplicate_field("values")); - } - values__ = - Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0) - ; - } - GeneratedField::Length => { - if length__.is_some() { - return Err(serde::de::Error::duplicate_field("length")); - } - length__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(ScalarFixedSizeBinary { - values: values__.unwrap_or_default(), - length: length__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarFixedSizeBinary", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarFunction { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Abs => "Abs", - Self::Acos => "Acos", - Self::Asin => "Asin", - Self::Atan => "Atan", - Self::Ascii => "Ascii", - Self::Ceil => "Ceil", - Self::Cos => "Cos", - Self::Digest => "Digest", - Self::Exp => "Exp", - Self::Floor => "Floor", - Self::Ln => "Ln", - Self::Log => "Log", - Self::Log10 => "Log10", - Self::Log2 => "Log2", - Self::Round => "Round", - Self::Signum => "Signum", - Self::Sin => "Sin", - Self::Sqrt => "Sqrt", - Self::Tan => "Tan", - Self::Trunc => "Trunc", - Self::Array => "Array", - Self::RegexpMatch => "RegexpMatch", - Self::BitLength => "BitLength", - Self::Btrim => "Btrim", - Self::CharacterLength => "CharacterLength", - Self::Chr => "Chr", - Self::Concat => "Concat", - Self::ConcatWithSeparator => "ConcatWithSeparator", - Self::DatePart => "DatePart", - Self::DateTrunc => "DateTrunc", - Self::InitCap => "InitCap", - Self::Left => "Left", - Self::Lpad => "Lpad", - Self::Lower => "Lower", - Self::Ltrim => "Ltrim", - Self::Md5 => "MD5", - Self::NullIf => "NullIf", - Self::OctetLength => "OctetLength", - Self::Random => "Random", - Self::RegexpReplace => "RegexpReplace", - Self::Repeat => "Repeat", - Self::Replace => "Replace", - Self::Reverse => "Reverse", - Self::Right => "Right", - Self::Rpad => "Rpad", - Self::Rtrim => "Rtrim", - Self::Sha224 => "SHA224", - Self::Sha256 => "SHA256", - Self::Sha384 => "SHA384", - Self::Sha512 => "SHA512", - Self::SplitPart => "SplitPart", - Self::StartsWith => "StartsWith", - Self::Strpos => "Strpos", - Self::Substr => "Substr", - Self::ToHex => "ToHex", - Self::ToTimestamp => "ToTimestamp", - Self::ToTimestampMillis => "ToTimestampMillis", - Self::ToTimestampMicros => "ToTimestampMicros", - Self::ToTimestampSeconds => "ToTimestampSeconds", - Self::Now => "Now", - Self::Translate => "Translate", - Self::Trim => "Trim", - Self::Upper => "Upper", - Self::Coalesce => "Coalesce", - Self::Power => "Power", - Self::StructFun => "StructFun", - Self::FromUnixtime => "FromUnixtime", - Self::Atan2 => "Atan2", - Self::DateBin => "DateBin", - Self::ArrowTypeof => "ArrowTypeof", - Self::CurrentDate => "CurrentDate", - Self::CurrentTime => "CurrentTime", - Self::Uuid => "Uuid", - Self::Cbrt => "Cbrt", - Self::Acosh => "Acosh", - Self::Asinh => "Asinh", - Self::Atanh => "Atanh", - Self::Sinh => "Sinh", - Self::Cosh => "Cosh", - Self::Tanh => "Tanh", - Self::Pi => "Pi", - Self::Degrees => "Degrees", - Self::Radians => "Radians", - Self::Factorial => "Factorial", - Self::Lcm => "Lcm", - Self::Gcd => "Gcd", - Self::ArrayAppend => "ArrayAppend", - Self::ArrayConcat => "ArrayConcat", - Self::ArrayDims => "ArrayDims", - Self::ArrayFill => "ArrayFill", - Self::ArrayLength => "ArrayLength", - Self::ArrayNdims => "ArrayNdims", - Self::ArrayPosition => "ArrayPosition", - Self::ArrayPositions => "ArrayPositions", - Self::ArrayPrepend => "ArrayPrepend", - Self::ArrayRemove => "ArrayRemove", - Self::ArrayReplace => "ArrayReplace", - Self::ArrayToString => "ArrayToString", - Self::Cardinality => "Cardinality", - Self::TrimArray => "TrimArray", - Self::Encode => "Encode", - Self::Decode => "Decode", - Self::Cot => "Cot", - Self::ArrayHas => "ArrayHas", - Self::ArrayHasAny => "ArrayHasAny", - Self::ArrayHasAll => "ArrayHasAll", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for ScalarFunction { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "Abs", - "Acos", - "Asin", - "Atan", - "Ascii", - "Ceil", - "Cos", - "Digest", - "Exp", - "Floor", - "Ln", - "Log", - "Log10", - "Log2", - "Round", - "Signum", - "Sin", - "Sqrt", - "Tan", - "Trunc", - "Array", - "RegexpMatch", - "BitLength", - "Btrim", - "CharacterLength", - "Chr", - "Concat", - "ConcatWithSeparator", - "DatePart", - "DateTrunc", - "InitCap", - "Left", - "Lpad", - "Lower", - "Ltrim", - "MD5", - "NullIf", - "OctetLength", - "Random", - "RegexpReplace", - "Repeat", - "Replace", - "Reverse", - "Right", - "Rpad", - "Rtrim", - "SHA224", - "SHA256", - "SHA384", - "SHA512", - "SplitPart", - "StartsWith", - "Strpos", - "Substr", - "ToHex", - "ToTimestamp", - "ToTimestampMillis", - "ToTimestampMicros", - "ToTimestampSeconds", - "Now", - "Translate", - "Trim", - "Upper", - "Coalesce", - "Power", - "StructFun", - "FromUnixtime", - "Atan2", - "DateBin", - "ArrowTypeof", - "CurrentDate", - "CurrentTime", - "Uuid", - "Cbrt", - "Acosh", - "Asinh", - "Atanh", - "Sinh", - "Cosh", - "Tanh", - "Pi", - "Degrees", - "Radians", - "Factorial", - "Lcm", - "Gcd", - "ArrayAppend", - "ArrayConcat", - "ArrayDims", - "ArrayFill", - "ArrayLength", - "ArrayNdims", - "ArrayPosition", - "ArrayPositions", - "ArrayPrepend", - "ArrayRemove", - "ArrayReplace", - "ArrayToString", - "Cardinality", - "TrimArray", - "Encode", - "Decode", - "Cot", - "ArrayHas", - "ArrayHasAny", - "ArrayHasAll", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarFunction; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(ScalarFunction::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(ScalarFunction::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "Abs" => Ok(ScalarFunction::Abs), - "Acos" => Ok(ScalarFunction::Acos), - "Asin" => Ok(ScalarFunction::Asin), - "Atan" => Ok(ScalarFunction::Atan), - "Ascii" => Ok(ScalarFunction::Ascii), - "Ceil" => Ok(ScalarFunction::Ceil), - "Cos" => Ok(ScalarFunction::Cos), - "Digest" => Ok(ScalarFunction::Digest), - "Exp" => Ok(ScalarFunction::Exp), - "Floor" => Ok(ScalarFunction::Floor), - "Ln" => Ok(ScalarFunction::Ln), - "Log" => Ok(ScalarFunction::Log), - "Log10" => Ok(ScalarFunction::Log10), - "Log2" => Ok(ScalarFunction::Log2), - "Round" => Ok(ScalarFunction::Round), - "Signum" => Ok(ScalarFunction::Signum), - "Sin" => Ok(ScalarFunction::Sin), - "Sqrt" => Ok(ScalarFunction::Sqrt), - "Tan" => Ok(ScalarFunction::Tan), - "Trunc" => Ok(ScalarFunction::Trunc), - "Array" => Ok(ScalarFunction::Array), - "RegexpMatch" => Ok(ScalarFunction::RegexpMatch), - "BitLength" => Ok(ScalarFunction::BitLength), - "Btrim" => Ok(ScalarFunction::Btrim), - "CharacterLength" => Ok(ScalarFunction::CharacterLength), - "Chr" => Ok(ScalarFunction::Chr), - "Concat" => Ok(ScalarFunction::Concat), - "ConcatWithSeparator" => Ok(ScalarFunction::ConcatWithSeparator), - "DatePart" => Ok(ScalarFunction::DatePart), - "DateTrunc" => Ok(ScalarFunction::DateTrunc), - "InitCap" => Ok(ScalarFunction::InitCap), - "Left" => Ok(ScalarFunction::Left), - "Lpad" => Ok(ScalarFunction::Lpad), - "Lower" => Ok(ScalarFunction::Lower), - "Ltrim" => Ok(ScalarFunction::Ltrim), - "MD5" => Ok(ScalarFunction::Md5), - "NullIf" => Ok(ScalarFunction::NullIf), - "OctetLength" => Ok(ScalarFunction::OctetLength), - "Random" => Ok(ScalarFunction::Random), - "RegexpReplace" => Ok(ScalarFunction::RegexpReplace), - "Repeat" => Ok(ScalarFunction::Repeat), - "Replace" => Ok(ScalarFunction::Replace), - "Reverse" => Ok(ScalarFunction::Reverse), - "Right" => Ok(ScalarFunction::Right), - "Rpad" => Ok(ScalarFunction::Rpad), - "Rtrim" => Ok(ScalarFunction::Rtrim), - "SHA224" => Ok(ScalarFunction::Sha224), - "SHA256" => Ok(ScalarFunction::Sha256), - "SHA384" => Ok(ScalarFunction::Sha384), - "SHA512" => Ok(ScalarFunction::Sha512), - "SplitPart" => Ok(ScalarFunction::SplitPart), - "StartsWith" => Ok(ScalarFunction::StartsWith), - "Strpos" => Ok(ScalarFunction::Strpos), - "Substr" => Ok(ScalarFunction::Substr), - "ToHex" => Ok(ScalarFunction::ToHex), - "ToTimestamp" => Ok(ScalarFunction::ToTimestamp), - "ToTimestampMillis" => Ok(ScalarFunction::ToTimestampMillis), - "ToTimestampMicros" => Ok(ScalarFunction::ToTimestampMicros), - "ToTimestampSeconds" => Ok(ScalarFunction::ToTimestampSeconds), - "Now" => Ok(ScalarFunction::Now), - "Translate" => Ok(ScalarFunction::Translate), - "Trim" => Ok(ScalarFunction::Trim), - "Upper" => Ok(ScalarFunction::Upper), - "Coalesce" => Ok(ScalarFunction::Coalesce), - "Power" => Ok(ScalarFunction::Power), - "StructFun" => Ok(ScalarFunction::StructFun), - "FromUnixtime" => Ok(ScalarFunction::FromUnixtime), - "Atan2" => Ok(ScalarFunction::Atan2), - "DateBin" => Ok(ScalarFunction::DateBin), - "ArrowTypeof" => Ok(ScalarFunction::ArrowTypeof), - "CurrentDate" => Ok(ScalarFunction::CurrentDate), - "CurrentTime" => Ok(ScalarFunction::CurrentTime), - "Uuid" => Ok(ScalarFunction::Uuid), - "Cbrt" => Ok(ScalarFunction::Cbrt), - "Acosh" => Ok(ScalarFunction::Acosh), - "Asinh" => Ok(ScalarFunction::Asinh), - "Atanh" => Ok(ScalarFunction::Atanh), - "Sinh" => Ok(ScalarFunction::Sinh), - "Cosh" => Ok(ScalarFunction::Cosh), - "Tanh" => Ok(ScalarFunction::Tanh), - "Pi" => Ok(ScalarFunction::Pi), - "Degrees" => Ok(ScalarFunction::Degrees), - "Radians" => Ok(ScalarFunction::Radians), - "Factorial" => Ok(ScalarFunction::Factorial), - "Lcm" => Ok(ScalarFunction::Lcm), - "Gcd" => Ok(ScalarFunction::Gcd), - "ArrayAppend" => Ok(ScalarFunction::ArrayAppend), - "ArrayConcat" => Ok(ScalarFunction::ArrayConcat), - "ArrayDims" => Ok(ScalarFunction::ArrayDims), - "ArrayFill" => Ok(ScalarFunction::ArrayFill), - "ArrayLength" => Ok(ScalarFunction::ArrayLength), - "ArrayNdims" => Ok(ScalarFunction::ArrayNdims), - "ArrayPosition" => Ok(ScalarFunction::ArrayPosition), - "ArrayPositions" => Ok(ScalarFunction::ArrayPositions), - "ArrayPrepend" => Ok(ScalarFunction::ArrayPrepend), - "ArrayRemove" => Ok(ScalarFunction::ArrayRemove), - "ArrayReplace" => Ok(ScalarFunction::ArrayReplace), - "ArrayToString" => Ok(ScalarFunction::ArrayToString), - "Cardinality" => Ok(ScalarFunction::Cardinality), - "TrimArray" => Ok(ScalarFunction::TrimArray), - "Encode" => Ok(ScalarFunction::Encode), - "Decode" => Ok(ScalarFunction::Decode), - "Cot" => Ok(ScalarFunction::Cot), - "ArrayHas" => Ok(ScalarFunction::ArrayHas), - "ArrayHasAny" => Ok(ScalarFunction::ArrayHasAny), - "ArrayHasAll" => Ok(ScalarFunction::ArrayHasAll), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for ScalarFunctionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.fun != 0 { - len += 1; - } - if !self.args.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarFunctionNode", len)?; - if self.fun != 0 { - let v = ScalarFunction::from_i32(self.fun) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.fun)))?; - struct_ser.serialize_field("fun", &v)?; - } - if !self.args.is_empty() { - struct_ser.serialize_field("args", &self.args)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarFunctionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "fun", - "args", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Fun, - Args, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "fun" => Ok(GeneratedField::Fun), - "args" => Ok(GeneratedField::Args), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarFunctionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarFunctionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut fun__ = None; - let mut args__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Fun => { - if fun__.is_some() { - return Err(serde::de::Error::duplicate_field("fun")); - } - fun__ = Some(map.next_value::()? as i32); - } - GeneratedField::Args => { - if args__.is_some() { - return Err(serde::de::Error::duplicate_field("args")); - } - args__ = Some(map.next_value()?); - } - } - } - Ok(ScalarFunctionNode { - fun: fun__.unwrap_or_default(), - args: args__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarFunctionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarListValue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.is_null { - len += 1; - } - if self.field.is_some() { - len += 1; - } - if !self.values.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarListValue", len)?; - if self.is_null { - struct_ser.serialize_field("isNull", &self.is_null)?; - } - if let Some(v) = self.field.as_ref() { - struct_ser.serialize_field("field", v)?; - } - if !self.values.is_empty() { - struct_ser.serialize_field("values", &self.values)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarListValue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "is_null", - "isNull", - "field", - "values", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - IsNull, - Field, - Values, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "isNull" | "is_null" => Ok(GeneratedField::IsNull), - "field" => Ok(GeneratedField::Field), - "values" => Ok(GeneratedField::Values), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarListValue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarListValue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut is_null__ = None; - let mut field__ = None; - let mut values__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::IsNull => { - if is_null__.is_some() { - return Err(serde::de::Error::duplicate_field("isNull")); - } - is_null__ = Some(map.next_value()?); - } - GeneratedField::Field => { - if field__.is_some() { - return Err(serde::de::Error::duplicate_field("field")); - } - field__ = map.next_value()?; - } - GeneratedField::Values => { - if values__.is_some() { - return Err(serde::de::Error::duplicate_field("values")); - } - values__ = Some(map.next_value()?); - } - } - } - Ok(ScalarListValue { - is_null: is_null__.unwrap_or_default(), - field: field__, - values: values__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarListValue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarTime32Value { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.value.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime32Value", len)?; - if let Some(v) = self.value.as_ref() { - match v { - scalar_time32_value::Value::Time32SecondValue(v) => { - struct_ser.serialize_field("time32SecondValue", v)?; - } - scalar_time32_value::Value::Time32MillisecondValue(v) => { - struct_ser.serialize_field("time32MillisecondValue", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarTime32Value { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "time32_second_value", - "time32SecondValue", - "time32_millisecond_value", - "time32MillisecondValue", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Time32SecondValue, - Time32MillisecondValue, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "time32SecondValue" | "time32_second_value" => Ok(GeneratedField::Time32SecondValue), - "time32MillisecondValue" | "time32_millisecond_value" => Ok(GeneratedField::Time32MillisecondValue), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarTime32Value; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarTime32Value") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut value__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Time32SecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time32SecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32SecondValue(x.0)); - } - GeneratedField::Time32MillisecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time32MillisecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time32_value::Value::Time32MillisecondValue(x.0)); - } - } - } - Ok(ScalarTime32Value { - value: value__, - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarTime32Value", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarTime64Value { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.value.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTime64Value", len)?; - if let Some(v) = self.value.as_ref() { - match v { - scalar_time64_value::Value::Time64MicrosecondValue(v) => { - struct_ser.serialize_field("time64MicrosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_time64_value::Value::Time64NanosecondValue(v) => { - struct_ser.serialize_field("time64NanosecondValue", ToString::to_string(&v).as_str())?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarTime64Value { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "time64_microsecond_value", - "time64MicrosecondValue", - "time64_nanosecond_value", - "time64NanosecondValue", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Time64MicrosecondValue, - Time64NanosecondValue, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "time64MicrosecondValue" | "time64_microsecond_value" => Ok(GeneratedField::Time64MicrosecondValue), - "time64NanosecondValue" | "time64_nanosecond_value" => Ok(GeneratedField::Time64NanosecondValue), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarTime64Value; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarTime64Value") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut value__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Time64MicrosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time64MicrosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64MicrosecondValue(x.0)); - } - GeneratedField::Time64NanosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time64NanosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_time64_value::Value::Time64NanosecondValue(x.0)); - } - } - } - Ok(ScalarTime64Value { - value: value__, - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarTime64Value", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarTimestampValue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.timezone.is_empty() { - len += 1; - } - if self.value.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarTimestampValue", len)?; - if !self.timezone.is_empty() { - struct_ser.serialize_field("timezone", &self.timezone)?; - } - if let Some(v) = self.value.as_ref() { - match v { - scalar_timestamp_value::Value::TimeMicrosecondValue(v) => { - struct_ser.serialize_field("timeMicrosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_timestamp_value::Value::TimeNanosecondValue(v) => { - struct_ser.serialize_field("timeNanosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_timestamp_value::Value::TimeSecondValue(v) => { - struct_ser.serialize_field("timeSecondValue", ToString::to_string(&v).as_str())?; - } - scalar_timestamp_value::Value::TimeMillisecondValue(v) => { - struct_ser.serialize_field("timeMillisecondValue", ToString::to_string(&v).as_str())?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarTimestampValue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "timezone", - "time_microsecond_value", - "timeMicrosecondValue", - "time_nanosecond_value", - "timeNanosecondValue", - "time_second_value", - "timeSecondValue", - "time_millisecond_value", - "timeMillisecondValue", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Timezone, - TimeMicrosecondValue, - TimeNanosecondValue, - TimeSecondValue, - TimeMillisecondValue, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "timezone" => Ok(GeneratedField::Timezone), - "timeMicrosecondValue" | "time_microsecond_value" => Ok(GeneratedField::TimeMicrosecondValue), - "timeNanosecondValue" | "time_nanosecond_value" => Ok(GeneratedField::TimeNanosecondValue), - "timeSecondValue" | "time_second_value" => Ok(GeneratedField::TimeSecondValue), - "timeMillisecondValue" | "time_millisecond_value" => Ok(GeneratedField::TimeMillisecondValue), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarTimestampValue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarTimestampValue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut timezone__ = None; - let mut value__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Timezone => { - if timezone__.is_some() { - return Err(serde::de::Error::duplicate_field("timezone")); - } - timezone__ = Some(map.next_value()?); - } - GeneratedField::TimeMicrosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeMicrosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMicrosecondValue(x.0)); - } - GeneratedField::TimeNanosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeNanosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeNanosecondValue(x.0)); - } - GeneratedField::TimeSecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeSecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeSecondValue(x.0)); - } - GeneratedField::TimeMillisecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timeMillisecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_timestamp_value::Value::TimeMillisecondValue(x.0)); - } - } - } - Ok(ScalarTimestampValue { - timezone: timezone__.unwrap_or_default(), - value: value__, - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarTimestampValue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarUdfExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.fun_name.is_empty() { - len += 1; - } - if !self.args.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarUDFExprNode", len)?; - if !self.fun_name.is_empty() { - struct_ser.serialize_field("funName", &self.fun_name)?; - } - if !self.args.is_empty() { - struct_ser.serialize_field("args", &self.args)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarUdfExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "fun_name", - "funName", - "args", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - FunName, - Args, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "funName" | "fun_name" => Ok(GeneratedField::FunName), - "args" => Ok(GeneratedField::Args), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarUdfExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarUDFExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut fun_name__ = None; - let mut args__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::FunName => { - if fun_name__.is_some() { - return Err(serde::de::Error::duplicate_field("funName")); - } - fun_name__ = Some(map.next_value()?); - } - GeneratedField::Args => { - if args__.is_some() { - return Err(serde::de::Error::duplicate_field("args")); - } - args__ = Some(map.next_value()?); - } - } - } - Ok(ScalarUdfExprNode { - fun_name: fun_name__.unwrap_or_default(), - args: args__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarUDFExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScalarValue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.value.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScalarValue", len)?; - if let Some(v) = self.value.as_ref() { - match v { - scalar_value::Value::NullValue(v) => { - struct_ser.serialize_field("nullValue", v)?; - } - scalar_value::Value::BoolValue(v) => { - struct_ser.serialize_field("boolValue", v)?; - } - scalar_value::Value::Utf8Value(v) => { - struct_ser.serialize_field("utf8Value", v)?; - } - scalar_value::Value::LargeUtf8Value(v) => { - struct_ser.serialize_field("largeUtf8Value", v)?; - } - scalar_value::Value::Int8Value(v) => { - struct_ser.serialize_field("int8Value", v)?; - } - scalar_value::Value::Int16Value(v) => { - struct_ser.serialize_field("int16Value", v)?; - } - scalar_value::Value::Int32Value(v) => { - struct_ser.serialize_field("int32Value", v)?; - } - scalar_value::Value::Int64Value(v) => { - struct_ser.serialize_field("int64Value", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::Uint8Value(v) => { - struct_ser.serialize_field("uint8Value", v)?; - } - scalar_value::Value::Uint16Value(v) => { - struct_ser.serialize_field("uint16Value", v)?; - } - scalar_value::Value::Uint32Value(v) => { - struct_ser.serialize_field("uint32Value", v)?; - } - scalar_value::Value::Uint64Value(v) => { - struct_ser.serialize_field("uint64Value", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::Float32Value(v) => { - struct_ser.serialize_field("float32Value", v)?; - } - scalar_value::Value::Float64Value(v) => { - struct_ser.serialize_field("float64Value", v)?; - } - scalar_value::Value::Date32Value(v) => { - struct_ser.serialize_field("date32Value", v)?; - } - scalar_value::Value::Time32Value(v) => { - struct_ser.serialize_field("time32Value", v)?; - } - scalar_value::Value::ListValue(v) => { - struct_ser.serialize_field("listValue", v)?; - } - scalar_value::Value::Decimal128Value(v) => { - struct_ser.serialize_field("decimal128Value", v)?; - } - scalar_value::Value::Date64Value(v) => { - struct_ser.serialize_field("date64Value", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::IntervalYearmonthValue(v) => { - struct_ser.serialize_field("intervalYearmonthValue", v)?; - } - scalar_value::Value::IntervalDaytimeValue(v) => { - struct_ser.serialize_field("intervalDaytimeValue", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::DurationSecondValue(v) => { - struct_ser.serialize_field("durationSecondValue", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::DurationMillisecondValue(v) => { - struct_ser.serialize_field("durationMillisecondValue", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::DurationMicrosecondValue(v) => { - struct_ser.serialize_field("durationMicrosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::DurationNanosecondValue(v) => { - struct_ser.serialize_field("durationNanosecondValue", ToString::to_string(&v).as_str())?; - } - scalar_value::Value::TimestampValue(v) => { - struct_ser.serialize_field("timestampValue", v)?; - } - scalar_value::Value::DictionaryValue(v) => { - struct_ser.serialize_field("dictionaryValue", v)?; - } - scalar_value::Value::BinaryValue(v) => { - struct_ser.serialize_field("binaryValue", pbjson::private::base64::encode(&v).as_str())?; - } - scalar_value::Value::LargeBinaryValue(v) => { - struct_ser.serialize_field("largeBinaryValue", pbjson::private::base64::encode(&v).as_str())?; - } - scalar_value::Value::Time64Value(v) => { - struct_ser.serialize_field("time64Value", v)?; - } - scalar_value::Value::IntervalMonthDayNano(v) => { - struct_ser.serialize_field("intervalMonthDayNano", v)?; - } - scalar_value::Value::StructValue(v) => { - struct_ser.serialize_field("structValue", v)?; - } - scalar_value::Value::FixedSizeBinaryValue(v) => { - struct_ser.serialize_field("fixedSizeBinaryValue", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScalarValue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "null_value", - "nullValue", - "bool_value", - "boolValue", - "utf8_value", - "utf8Value", - "large_utf8_value", - "largeUtf8Value", - "int8_value", - "int8Value", - "int16_value", - "int16Value", - "int32_value", - "int32Value", - "int64_value", - "int64Value", - "uint8_value", - "uint8Value", - "uint16_value", - "uint16Value", - "uint32_value", - "uint32Value", - "uint64_value", - "uint64Value", - "float32_value", - "float32Value", - "float64_value", - "float64Value", - "date_32_value", - "date32Value", - "time32_value", - "time32Value", - "list_value", - "listValue", - "decimal128_value", - "decimal128Value", - "date_64_value", - "date64Value", - "interval_yearmonth_value", - "intervalYearmonthValue", - "interval_daytime_value", - "intervalDaytimeValue", - "duration_second_value", - "durationSecondValue", - "duration_millisecond_value", - "durationMillisecondValue", - "duration_microsecond_value", - "durationMicrosecondValue", - "duration_nanosecond_value", - "durationNanosecondValue", - "timestamp_value", - "timestampValue", - "dictionary_value", - "dictionaryValue", - "binary_value", - "binaryValue", - "large_binary_value", - "largeBinaryValue", - "time64_value", - "time64Value", - "interval_month_day_nano", - "intervalMonthDayNano", - "struct_value", - "structValue", - "fixed_size_binary_value", - "fixedSizeBinaryValue", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - NullValue, - BoolValue, - Utf8Value, - LargeUtf8Value, - Int8Value, - Int16Value, - Int32Value, - Int64Value, - Uint8Value, - Uint16Value, - Uint32Value, - Uint64Value, - Float32Value, - Float64Value, - Date32Value, - Time32Value, - ListValue, - Decimal128Value, - Date64Value, - IntervalYearmonthValue, - IntervalDaytimeValue, - DurationSecondValue, - DurationMillisecondValue, - DurationMicrosecondValue, - DurationNanosecondValue, - TimestampValue, - DictionaryValue, - BinaryValue, - LargeBinaryValue, - Time64Value, - IntervalMonthDayNano, - StructValue, - FixedSizeBinaryValue, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "nullValue" | "null_value" => Ok(GeneratedField::NullValue), - "boolValue" | "bool_value" => Ok(GeneratedField::BoolValue), - "utf8Value" | "utf8_value" => Ok(GeneratedField::Utf8Value), - "largeUtf8Value" | "large_utf8_value" => Ok(GeneratedField::LargeUtf8Value), - "int8Value" | "int8_value" => Ok(GeneratedField::Int8Value), - "int16Value" | "int16_value" => Ok(GeneratedField::Int16Value), - "int32Value" | "int32_value" => Ok(GeneratedField::Int32Value), - "int64Value" | "int64_value" => Ok(GeneratedField::Int64Value), - "uint8Value" | "uint8_value" => Ok(GeneratedField::Uint8Value), - "uint16Value" | "uint16_value" => Ok(GeneratedField::Uint16Value), - "uint32Value" | "uint32_value" => Ok(GeneratedField::Uint32Value), - "uint64Value" | "uint64_value" => Ok(GeneratedField::Uint64Value), - "float32Value" | "float32_value" => Ok(GeneratedField::Float32Value), - "float64Value" | "float64_value" => Ok(GeneratedField::Float64Value), - "date32Value" | "date_32_value" => Ok(GeneratedField::Date32Value), - "time32Value" | "time32_value" => Ok(GeneratedField::Time32Value), - "listValue" | "list_value" => Ok(GeneratedField::ListValue), - "decimal128Value" | "decimal128_value" => Ok(GeneratedField::Decimal128Value), - "date64Value" | "date_64_value" => Ok(GeneratedField::Date64Value), - "intervalYearmonthValue" | "interval_yearmonth_value" => Ok(GeneratedField::IntervalYearmonthValue), - "intervalDaytimeValue" | "interval_daytime_value" => Ok(GeneratedField::IntervalDaytimeValue), - "durationSecondValue" | "duration_second_value" => Ok(GeneratedField::DurationSecondValue), - "durationMillisecondValue" | "duration_millisecond_value" => Ok(GeneratedField::DurationMillisecondValue), - "durationMicrosecondValue" | "duration_microsecond_value" => Ok(GeneratedField::DurationMicrosecondValue), - "durationNanosecondValue" | "duration_nanosecond_value" => Ok(GeneratedField::DurationNanosecondValue), - "timestampValue" | "timestamp_value" => Ok(GeneratedField::TimestampValue), - "dictionaryValue" | "dictionary_value" => Ok(GeneratedField::DictionaryValue), - "binaryValue" | "binary_value" => Ok(GeneratedField::BinaryValue), - "largeBinaryValue" | "large_binary_value" => Ok(GeneratedField::LargeBinaryValue), - "time64Value" | "time64_value" => Ok(GeneratedField::Time64Value), - "intervalMonthDayNano" | "interval_month_day_nano" => Ok(GeneratedField::IntervalMonthDayNano), - "structValue" | "struct_value" => Ok(GeneratedField::StructValue), - "fixedSizeBinaryValue" | "fixed_size_binary_value" => Ok(GeneratedField::FixedSizeBinaryValue), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScalarValue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScalarValue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut value__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::NullValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("nullValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::NullValue) -; - } - GeneratedField::BoolValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("boolValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::BoolValue); - } - GeneratedField::Utf8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("utf8Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Utf8Value); - } - GeneratedField::LargeUtf8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("largeUtf8Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::LargeUtf8Value); - } - GeneratedField::Int8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int8Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int8Value(x.0)); - } - GeneratedField::Int16Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int16Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int16Value(x.0)); - } - GeneratedField::Int32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int32Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int32Value(x.0)); - } - GeneratedField::Int64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("int64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Int64Value(x.0)); - } - GeneratedField::Uint8Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint8Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint8Value(x.0)); - } - GeneratedField::Uint16Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint16Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint16Value(x.0)); - } - GeneratedField::Uint32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint32Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint32Value(x.0)); - } - GeneratedField::Uint64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("uint64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Uint64Value(x.0)); - } - GeneratedField::Float32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("float32Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float32Value(x.0)); - } - GeneratedField::Float64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("float64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Float64Value(x.0)); - } - GeneratedField::Date32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("date32Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date32Value(x.0)); - } - GeneratedField::Time32Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time32Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time32Value) -; - } - GeneratedField::ListValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("listValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::ListValue) -; - } - GeneratedField::Decimal128Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("decimal128Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Decimal128Value) -; - } - GeneratedField::Date64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("date64Value")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::Date64Value(x.0)); - } - GeneratedField::IntervalYearmonthValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("intervalYearmonthValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalYearmonthValue(x.0)); - } - GeneratedField::IntervalDaytimeValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("intervalDaytimeValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::IntervalDaytimeValue(x.0)); - } - GeneratedField::DurationSecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("durationSecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::DurationSecondValue(x.0)); - } - GeneratedField::DurationMillisecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("durationMillisecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::DurationMillisecondValue(x.0)); - } - GeneratedField::DurationMicrosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("durationMicrosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::DurationMicrosecondValue(x.0)); - } - GeneratedField::DurationNanosecondValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("durationNanosecondValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| scalar_value::Value::DurationNanosecondValue(x.0)); - } - GeneratedField::TimestampValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("timestampValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::TimestampValue) -; - } - GeneratedField::DictionaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("dictionaryValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::DictionaryValue) -; - } - GeneratedField::BinaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("binaryValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::BinaryValue(x.0)); - } - GeneratedField::LargeBinaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("largeBinaryValue")); - } - value__ = map.next_value::<::std::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| scalar_value::Value::LargeBinaryValue(x.0)); - } - GeneratedField::Time64Value => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("time64Value")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::Time64Value) -; - } - GeneratedField::IntervalMonthDayNano => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("intervalMonthDayNano")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::IntervalMonthDayNano) -; - } - GeneratedField::StructValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("structValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::StructValue) -; - } - GeneratedField::FixedSizeBinaryValue => { - if value__.is_some() { - return Err(serde::de::Error::duplicate_field("fixedSizeBinaryValue")); - } - value__ = map.next_value::<::std::option::Option<_>>()?.map(scalar_value::Value::FixedSizeBinaryValue) -; - } - } - } - Ok(ScalarValue { - value: value__, - }) - } - } - deserializer.deserialize_struct("datafusion.ScalarValue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ScanLimit { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.limit != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ScanLimit", len)?; - if self.limit != 0 { - struct_ser.serialize_field("limit", &self.limit)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ScanLimit { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "limit", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Limit, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "limit" => Ok(GeneratedField::Limit), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ScanLimit; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ScanLimit") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut limit__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Limit => { - if limit__.is_some() { - return Err(serde::de::Error::duplicate_field("limit")); - } - limit__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(ScanLimit { - limit: limit__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ScanLimit", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Schema { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.columns.is_empty() { - len += 1; - } - if !self.metadata.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Schema", len)?; - if !self.columns.is_empty() { - struct_ser.serialize_field("columns", &self.columns)?; - } - if !self.metadata.is_empty() { - struct_ser.serialize_field("metadata", &self.metadata)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Schema { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "columns", - "metadata", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Columns, - Metadata, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "columns" => Ok(GeneratedField::Columns), - "metadata" => Ok(GeneratedField::Metadata), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Schema; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Schema") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut columns__ = None; - let mut metadata__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Columns => { - if columns__.is_some() { - return Err(serde::de::Error::duplicate_field("columns")); - } - columns__ = Some(map.next_value()?); - } - GeneratedField::Metadata => { - if metadata__.is_some() { - return Err(serde::de::Error::duplicate_field("metadata")); - } - metadata__ = Some( - map.next_value::>()? - ); - } - } - } - Ok(Schema { - columns: columns__.unwrap_or_default(), - metadata: metadata__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Schema", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SelectionExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SelectionExecNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SelectionExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SelectionExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SelectionExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(SelectionExecNode { - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.SelectionExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SelectionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SelectionNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SelectionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "expr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Expr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SelectionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SelectionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - } - } - Ok(SelectionNode { - input: input__, - expr: expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.SelectionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SimilarToNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.negated { - len += 1; - } - if self.expr.is_some() { - len += 1; - } - if self.pattern.is_some() { - len += 1; - } - if !self.escape_char.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SimilarToNode", len)?; - if self.negated { - struct_ser.serialize_field("negated", &self.negated)?; - } - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.pattern.as_ref() { - struct_ser.serialize_field("pattern", v)?; - } - if !self.escape_char.is_empty() { - struct_ser.serialize_field("escapeChar", &self.escape_char)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SimilarToNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "negated", - "expr", - "pattern", - "escape_char", - "escapeChar", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Negated, - Expr, - Pattern, - EscapeChar, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "negated" => Ok(GeneratedField::Negated), - "expr" => Ok(GeneratedField::Expr), - "pattern" => Ok(GeneratedField::Pattern), - "escapeChar" | "escape_char" => Ok(GeneratedField::EscapeChar), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SimilarToNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SimilarToNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut negated__ = None; - let mut expr__ = None; - let mut pattern__ = None; - let mut escape_char__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Negated => { - if negated__.is_some() { - return Err(serde::de::Error::duplicate_field("negated")); - } - negated__ = Some(map.next_value()?); - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Pattern => { - if pattern__.is_some() { - return Err(serde::de::Error::duplicate_field("pattern")); - } - pattern__ = map.next_value()?; - } - GeneratedField::EscapeChar => { - if escape_char__.is_some() { - return Err(serde::de::Error::duplicate_field("escapeChar")); - } - escape_char__ = Some(map.next_value()?); - } - } - } - Ok(SimilarToNode { - negated: negated__.unwrap_or_default(), - expr: expr__, - pattern: pattern__, - escape_char: escape_char__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.SimilarToNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SortExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.expr.is_empty() { - len += 1; - } - if self.fetch != 0 { - len += 1; - } - if self.preserve_partitioning { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SortExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; - } - if self.preserve_partitioning { - struct_ser.serialize_field("preservePartitioning", &self.preserve_partitioning)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SortExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "expr", - "fetch", - "preserve_partitioning", - "preservePartitioning", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Expr, - Fetch, - PreservePartitioning, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - "fetch" => Ok(GeneratedField::Fetch), - "preservePartitioning" | "preserve_partitioning" => Ok(GeneratedField::PreservePartitioning), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SortExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SortExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut expr__ = None; - let mut fetch__ = None; - let mut preserve_partitioning__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); - } - fetch__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::PreservePartitioning => { - if preserve_partitioning__.is_some() { - return Err(serde::de::Error::duplicate_field("preservePartitioning")); - } - preserve_partitioning__ = Some(map.next_value()?); - } - } - } - Ok(SortExecNode { - input: input__, - expr: expr__.unwrap_or_default(), - fetch: fetch__.unwrap_or_default(), - preserve_partitioning: preserve_partitioning__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.SortExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SortExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.asc { - len += 1; - } - if self.nulls_first { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SortExprNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if self.asc { - struct_ser.serialize_field("asc", &self.asc)?; - } - if self.nulls_first { - struct_ser.serialize_field("nullsFirst", &self.nulls_first)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SortExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "asc", - "nulls_first", - "nullsFirst", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - Asc, - NullsFirst, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "asc" => Ok(GeneratedField::Asc), - "nullsFirst" | "nulls_first" => Ok(GeneratedField::NullsFirst), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SortExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SortExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut asc__ = None; - let mut nulls_first__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::Asc => { - if asc__.is_some() { - return Err(serde::de::Error::duplicate_field("asc")); - } - asc__ = Some(map.next_value()?); - } - GeneratedField::NullsFirst => { - if nulls_first__.is_some() { - return Err(serde::de::Error::duplicate_field("nullsFirst")); - } - nulls_first__ = Some(map.next_value()?); - } - } - } - Ok(SortExprNode { - expr: expr__, - asc: asc__.unwrap_or_default(), - nulls_first: nulls_first__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.SortExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SortNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.expr.is_empty() { - len += 1; - } - if self.fetch != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SortNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SortNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "expr", - "fetch", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Expr, - Fetch, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - "fetch" => Ok(GeneratedField::Fetch), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SortNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SortNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut expr__ = None; - let mut fetch__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); - } - fetch__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(SortNode { - input: input__, - expr: expr__.unwrap_or_default(), - fetch: fetch__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.SortNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SortPreservingMergeExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.expr.is_empty() { - len += 1; - } - if self.fetch != 0 { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SortPreservingMergeExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.expr.is_empty() { - struct_ser.serialize_field("expr", &self.expr)?; - } - if self.fetch != 0 { - struct_ser.serialize_field("fetch", ToString::to_string(&self.fetch).as_str())?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SortPreservingMergeExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "expr", - "fetch", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Expr, - Fetch, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "expr" => Ok(GeneratedField::Expr), - "fetch" => Ok(GeneratedField::Fetch), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SortPreservingMergeExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SortPreservingMergeExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut expr__ = None; - let mut fetch__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = Some(map.next_value()?); - } - GeneratedField::Fetch => { - if fetch__.is_some() { - return Err(serde::de::Error::duplicate_field("fetch")); - } - fetch__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - } - } - Ok(SortPreservingMergeExecNode { - input: input__, - expr: expr__.unwrap_or_default(), - fetch: fetch__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.SortPreservingMergeExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Statistics { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.num_rows != 0 { - len += 1; - } - if self.total_byte_size != 0 { - len += 1; - } - if !self.column_stats.is_empty() { - len += 1; - } - if self.is_exact { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Statistics", len)?; - if self.num_rows != 0 { - struct_ser.serialize_field("numRows", ToString::to_string(&self.num_rows).as_str())?; - } - if self.total_byte_size != 0 { - struct_ser.serialize_field("totalByteSize", ToString::to_string(&self.total_byte_size).as_str())?; - } - if !self.column_stats.is_empty() { - struct_ser.serialize_field("columnStats", &self.column_stats)?; - } - if self.is_exact { - struct_ser.serialize_field("isExact", &self.is_exact)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Statistics { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "num_rows", - "numRows", - "total_byte_size", - "totalByteSize", - "column_stats", - "columnStats", - "is_exact", - "isExact", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - NumRows, - TotalByteSize, - ColumnStats, - IsExact, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "numRows" | "num_rows" => Ok(GeneratedField::NumRows), - "totalByteSize" | "total_byte_size" => Ok(GeneratedField::TotalByteSize), - "columnStats" | "column_stats" => Ok(GeneratedField::ColumnStats), - "isExact" | "is_exact" => Ok(GeneratedField::IsExact), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Statistics; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Statistics") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut num_rows__ = None; - let mut total_byte_size__ = None; - let mut column_stats__ = None; - let mut is_exact__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::NumRows => { - if num_rows__.is_some() { - return Err(serde::de::Error::duplicate_field("numRows")); - } - num_rows__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::TotalByteSize => { - if total_byte_size__.is_some() { - return Err(serde::de::Error::duplicate_field("totalByteSize")); - } - total_byte_size__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::ColumnStats => { - if column_stats__.is_some() { - return Err(serde::de::Error::duplicate_field("columnStats")); - } - column_stats__ = Some(map.next_value()?); - } - GeneratedField::IsExact => { - if is_exact__.is_some() { - return Err(serde::de::Error::duplicate_field("isExact")); - } - is_exact__ = Some(map.next_value()?); - } - } - } - Ok(Statistics { - num_rows: num_rows__.unwrap_or_default(), - total_byte_size: total_byte_size__.unwrap_or_default(), - column_stats: column_stats__.unwrap_or_default(), - is_exact: is_exact__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Statistics", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for StringifiedPlan { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.plan_type.is_some() { - len += 1; - } - if !self.plan.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.StringifiedPlan", len)?; - if let Some(v) = self.plan_type.as_ref() { - struct_ser.serialize_field("planType", v)?; - } - if !self.plan.is_empty() { - struct_ser.serialize_field("plan", &self.plan)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for StringifiedPlan { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "plan_type", - "planType", - "plan", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - PlanType, - Plan, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "planType" | "plan_type" => Ok(GeneratedField::PlanType), - "plan" => Ok(GeneratedField::Plan), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = StringifiedPlan; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.StringifiedPlan") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut plan_type__ = None; - let mut plan__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::PlanType => { - if plan_type__.is_some() { - return Err(serde::de::Error::duplicate_field("planType")); - } - plan_type__ = map.next_value()?; - } - GeneratedField::Plan => { - if plan__.is_some() { - return Err(serde::de::Error::duplicate_field("plan")); - } - plan__ = Some(map.next_value()?); - } - } - } - Ok(StringifiedPlan { - plan_type: plan_type__, - plan: plan__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.StringifiedPlan", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Struct { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.sub_field_types.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Struct", len)?; - if !self.sub_field_types.is_empty() { - struct_ser.serialize_field("subFieldTypes", &self.sub_field_types)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Struct { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "sub_field_types", - "subFieldTypes", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - SubFieldTypes, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "subFieldTypes" | "sub_field_types" => Ok(GeneratedField::SubFieldTypes), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Struct; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Struct") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut sub_field_types__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::SubFieldTypes => { - if sub_field_types__.is_some() { - return Err(serde::de::Error::duplicate_field("subFieldTypes")); - } - sub_field_types__ = Some(map.next_value()?); - } - } - } - Ok(Struct { - sub_field_types: sub_field_types__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Struct", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for StructValue { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.field_values.is_empty() { - len += 1; - } - if !self.fields.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.StructValue", len)?; - if !self.field_values.is_empty() { - struct_ser.serialize_field("fieldValues", &self.field_values)?; - } - if !self.fields.is_empty() { - struct_ser.serialize_field("fields", &self.fields)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for StructValue { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "field_values", - "fieldValues", - "fields", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - FieldValues, - Fields, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "fieldValues" | "field_values" => Ok(GeneratedField::FieldValues), - "fields" => Ok(GeneratedField::Fields), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = StructValue; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.StructValue") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut field_values__ = None; - let mut fields__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::FieldValues => { - if field_values__.is_some() { - return Err(serde::de::Error::duplicate_field("fieldValues")); - } - field_values__ = Some(map.next_value()?); - } - GeneratedField::Fields => { - if fields__.is_some() { - return Err(serde::de::Error::duplicate_field("fields")); - } - fields__ = Some(map.next_value()?); - } - } - } - Ok(StructValue { - field_values: field_values__.unwrap_or_default(), - fields: fields__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.StructValue", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for SubqueryAliasNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if self.alias.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.SubqueryAliasNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.alias.as_ref() { - struct_ser.serialize_field("alias", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for SubqueryAliasNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "alias", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - Alias, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "alias" => Ok(GeneratedField::Alias), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = SubqueryAliasNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.SubqueryAliasNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut alias__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Alias => { - if alias__.is_some() { - return Err(serde::de::Error::duplicate_field("alias")); - } - alias__ = map.next_value()?; - } - } - } - Ok(SubqueryAliasNode { - input: input__, - alias: alias__, - }) - } - } - deserializer.deserialize_struct("datafusion.SubqueryAliasNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for TimeUnit { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Second => "Second", - Self::Millisecond => "Millisecond", - Self::Microsecond => "Microsecond", - Self::Nanosecond => "Nanosecond", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for TimeUnit { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "Second", - "Millisecond", - "Microsecond", - "Nanosecond", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TimeUnit; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(TimeUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(TimeUnit::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "Second" => Ok(TimeUnit::Second), - "Millisecond" => Ok(TimeUnit::Millisecond), - "Microsecond" => Ok(TimeUnit::Microsecond), - "Nanosecond" => Ok(TimeUnit::Nanosecond), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for Timestamp { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.time_unit != 0 { - len += 1; - } - if !self.timezone.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Timestamp", len)?; - if self.time_unit != 0 { - let v = TimeUnit::from_i32(self.time_unit) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.time_unit)))?; - struct_ser.serialize_field("timeUnit", &v)?; - } - if !self.timezone.is_empty() { - struct_ser.serialize_field("timezone", &self.timezone)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Timestamp { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "time_unit", - "timeUnit", - "timezone", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - TimeUnit, - Timezone, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "timeUnit" | "time_unit" => Ok(GeneratedField::TimeUnit), - "timezone" => Ok(GeneratedField::Timezone), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Timestamp; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Timestamp") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut time_unit__ = None; - let mut timezone__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::TimeUnit => { - if time_unit__.is_some() { - return Err(serde::de::Error::duplicate_field("timeUnit")); - } - time_unit__ = Some(map.next_value::()? as i32); - } - GeneratedField::Timezone => { - if timezone__.is_some() { - return Err(serde::de::Error::duplicate_field("timezone")); - } - timezone__ = Some(map.next_value()?); - } - } - } - Ok(Timestamp { - time_unit: time_unit__.unwrap_or_default(), - timezone: timezone__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Timestamp", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for TryCastNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if self.arrow_type.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.TryCastNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if let Some(v) = self.arrow_type.as_ref() { - struct_ser.serialize_field("arrowType", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for TryCastNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "arrow_type", - "arrowType", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - ArrowType, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "arrowType" | "arrow_type" => Ok(GeneratedField::ArrowType), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = TryCastNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.TryCastNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut arrow_type__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::ArrowType => { - if arrow_type__.is_some() { - return Err(serde::de::Error::duplicate_field("arrowType")); - } - arrow_type__ = map.next_value()?; - } - } - } - Ok(TryCastNode { - expr: expr__, - arrow_type: arrow_type__, - }) - } - } - deserializer.deserialize_struct("datafusion.TryCastNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for Union { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.union_types.is_empty() { - len += 1; - } - if self.union_mode != 0 { - len += 1; - } - if !self.type_ids.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.Union", len)?; - if !self.union_types.is_empty() { - struct_ser.serialize_field("unionTypes", &self.union_types)?; - } - if self.union_mode != 0 { - let v = UnionMode::from_i32(self.union_mode) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.union_mode)))?; - struct_ser.serialize_field("unionMode", &v)?; - } - if !self.type_ids.is_empty() { - struct_ser.serialize_field("typeIds", &self.type_ids)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for Union { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "union_types", - "unionTypes", - "union_mode", - "unionMode", - "type_ids", - "typeIds", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - UnionTypes, - UnionMode, - TypeIds, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "unionTypes" | "union_types" => Ok(GeneratedField::UnionTypes), - "unionMode" | "union_mode" => Ok(GeneratedField::UnionMode), - "typeIds" | "type_ids" => Ok(GeneratedField::TypeIds), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = Union; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.Union") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut union_types__ = None; - let mut union_mode__ = None; - let mut type_ids__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::UnionTypes => { - if union_types__.is_some() { - return Err(serde::de::Error::duplicate_field("unionTypes")); - } - union_types__ = Some(map.next_value()?); - } - GeneratedField::UnionMode => { - if union_mode__.is_some() { - return Err(serde::de::Error::duplicate_field("unionMode")); - } - union_mode__ = Some(map.next_value::()? as i32); - } - GeneratedField::TypeIds => { - if type_ids__.is_some() { - return Err(serde::de::Error::duplicate_field("typeIds")); - } - type_ids__ = - Some(map.next_value::>>()? - .into_iter().map(|x| x.0).collect()) - ; - } - } - } - Ok(Union { - union_types: union_types__.unwrap_or_default(), - union_mode: union_mode__.unwrap_or_default(), - type_ids: type_ids__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.Union", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for UnionExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.inputs.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.UnionExecNode", len)?; - if !self.inputs.is_empty() { - struct_ser.serialize_field("inputs", &self.inputs)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for UnionExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "inputs", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Inputs, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "inputs" => Ok(GeneratedField::Inputs), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UnionExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.UnionExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut inputs__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Inputs => { - if inputs__.is_some() { - return Err(serde::de::Error::duplicate_field("inputs")); - } - inputs__ = Some(map.next_value()?); - } - } - } - Ok(UnionExecNode { - inputs: inputs__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.UnionExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for UnionMode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Sparse => "sparse", - Self::Dense => "dense", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for UnionMode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "sparse", - "dense", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UnionMode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(UnionMode::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(UnionMode::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "sparse" => Ok(UnionMode::Sparse), - "dense" => Ok(UnionMode::Dense), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for UnionNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if !self.inputs.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.UnionNode", len)?; - if !self.inputs.is_empty() { - struct_ser.serialize_field("inputs", &self.inputs)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for UnionNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "inputs", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Inputs, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "inputs" => Ok(GeneratedField::Inputs), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = UnionNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.UnionNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut inputs__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Inputs => { - if inputs__.is_some() { - return Err(serde::de::Error::duplicate_field("inputs")); - } - inputs__ = Some(map.next_value()?); - } - } - } - Ok(UnionNode { - inputs: inputs__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.UnionNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ValuesNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.n_cols != 0 { - len += 1; - } - if !self.values_list.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ValuesNode", len)?; - if self.n_cols != 0 { - struct_ser.serialize_field("nCols", ToString::to_string(&self.n_cols).as_str())?; - } - if !self.values_list.is_empty() { - struct_ser.serialize_field("valuesList", &self.values_list)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ValuesNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "n_cols", - "nCols", - "values_list", - "valuesList", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - NCols, - ValuesList, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "nCols" | "n_cols" => Ok(GeneratedField::NCols), - "valuesList" | "values_list" => Ok(GeneratedField::ValuesList), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ValuesNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ValuesNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut n_cols__ = None; - let mut values_list__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::NCols => { - if n_cols__.is_some() { - return Err(serde::de::Error::duplicate_field("nCols")); - } - n_cols__ = - Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0) - ; - } - GeneratedField::ValuesList => { - if values_list__.is_some() { - return Err(serde::de::Error::duplicate_field("valuesList")); - } - values_list__ = Some(map.next_value()?); - } - } - } - Ok(ValuesNode { - n_cols: n_cols__.unwrap_or_default(), - values_list: values_list__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ValuesNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for ViewTableScanNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.table_name.is_some() { - len += 1; - } - if self.input.is_some() { - len += 1; - } - if self.schema.is_some() { - len += 1; - } - if self.projection.is_some() { - len += 1; - } - if !self.definition.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.ViewTableScanNode", len)?; - if let Some(v) = self.table_name.as_ref() { - struct_ser.serialize_field("tableName", v)?; - } - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if let Some(v) = self.schema.as_ref() { - struct_ser.serialize_field("schema", v)?; - } - if let Some(v) = self.projection.as_ref() { - struct_ser.serialize_field("projection", v)?; - } - if !self.definition.is_empty() { - struct_ser.serialize_field("definition", &self.definition)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for ViewTableScanNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "table_name", - "tableName", - "input", - "schema", - "projection", - "definition", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - TableName, - Input, - Schema, - Projection, - Definition, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "tableName" | "table_name" => Ok(GeneratedField::TableName), - "input" => Ok(GeneratedField::Input), - "schema" => Ok(GeneratedField::Schema), - "projection" => Ok(GeneratedField::Projection), - "definition" => Ok(GeneratedField::Definition), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = ViewTableScanNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.ViewTableScanNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut table_name__ = None; - let mut input__ = None; - let mut schema__ = None; - let mut projection__ = None; - let mut definition__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::TableName => { - if table_name__.is_some() { - return Err(serde::de::Error::duplicate_field("tableName")); - } - table_name__ = map.next_value()?; - } - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::Schema => { - if schema__.is_some() { - return Err(serde::de::Error::duplicate_field("schema")); - } - schema__ = map.next_value()?; - } - GeneratedField::Projection => { - if projection__.is_some() { - return Err(serde::de::Error::duplicate_field("projection")); - } - projection__ = map.next_value()?; - } - GeneratedField::Definition => { - if definition__.is_some() { - return Err(serde::de::Error::duplicate_field("definition")); - } - definition__ = Some(map.next_value()?); - } - } - } - Ok(ViewTableScanNode { - table_name: table_name__, - input: input__, - schema: schema__, - projection: projection__, - definition: definition__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.ViewTableScanNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for WhenThen { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.when_expr.is_some() { - len += 1; - } - if self.then_expr.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.WhenThen", len)?; - if let Some(v) = self.when_expr.as_ref() { - struct_ser.serialize_field("whenExpr", v)?; - } - if let Some(v) = self.then_expr.as_ref() { - struct_ser.serialize_field("thenExpr", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for WhenThen { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "when_expr", - "whenExpr", - "then_expr", - "thenExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - WhenExpr, - ThenExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "whenExpr" | "when_expr" => Ok(GeneratedField::WhenExpr), - "thenExpr" | "then_expr" => Ok(GeneratedField::ThenExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WhenThen; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.WhenThen") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut when_expr__ = None; - let mut then_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::WhenExpr => { - if when_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("whenExpr")); - } - when_expr__ = map.next_value()?; - } - GeneratedField::ThenExpr => { - if then_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("thenExpr")); - } - then_expr__ = map.next_value()?; - } - } - } - Ok(WhenThen { - when_expr: when_expr__, - then_expr: then_expr__, - }) - } - } - deserializer.deserialize_struct("datafusion.WhenThen", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for WindowAggExecNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.window_expr.is_empty() { - len += 1; - } - if !self.window_expr_name.is_empty() { - len += 1; - } - if self.input_schema.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.WindowAggExecNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.window_expr.is_empty() { - struct_ser.serialize_field("windowExpr", &self.window_expr)?; - } - if !self.window_expr_name.is_empty() { - struct_ser.serialize_field("windowExprName", &self.window_expr_name)?; - } - if let Some(v) = self.input_schema.as_ref() { - struct_ser.serialize_field("inputSchema", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for WindowAggExecNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "window_expr", - "windowExpr", - "window_expr_name", - "windowExprName", - "input_schema", - "inputSchema", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - WindowExpr, - WindowExprName, - InputSchema, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), - "windowExprName" | "window_expr_name" => Ok(GeneratedField::WindowExprName), - "inputSchema" | "input_schema" => Ok(GeneratedField::InputSchema), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WindowAggExecNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.WindowAggExecNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut window_expr__ = None; - let mut window_expr_name__ = None; - let mut input_schema__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::WindowExpr => { - if window_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("windowExpr")); - } - window_expr__ = Some(map.next_value()?); - } - GeneratedField::WindowExprName => { - if window_expr_name__.is_some() { - return Err(serde::de::Error::duplicate_field("windowExprName")); - } - window_expr_name__ = Some(map.next_value()?); - } - GeneratedField::InputSchema => { - if input_schema__.is_some() { - return Err(serde::de::Error::duplicate_field("inputSchema")); - } - input_schema__ = map.next_value()?; - } - } - } - Ok(WindowAggExecNode { - input: input__, - window_expr: window_expr__.unwrap_or_default(), - window_expr_name: window_expr_name__.unwrap_or_default(), - input_schema: input_schema__, - }) - } - } - deserializer.deserialize_struct("datafusion.WindowAggExecNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for WindowExprNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.expr.is_some() { - len += 1; - } - if !self.partition_by.is_empty() { - len += 1; - } - if !self.order_by.is_empty() { - len += 1; - } - if self.window_frame.is_some() { - len += 1; - } - if self.window_function.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.WindowExprNode", len)?; - if let Some(v) = self.expr.as_ref() { - struct_ser.serialize_field("expr", v)?; - } - if !self.partition_by.is_empty() { - struct_ser.serialize_field("partitionBy", &self.partition_by)?; - } - if !self.order_by.is_empty() { - struct_ser.serialize_field("orderBy", &self.order_by)?; - } - if let Some(v) = self.window_frame.as_ref() { - struct_ser.serialize_field("windowFrame", v)?; - } - if let Some(v) = self.window_function.as_ref() { - match v { - window_expr_node::WindowFunction::AggrFunction(v) => { - let v = AggregateFunction::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("aggrFunction", &v)?; - } - window_expr_node::WindowFunction::BuiltInFunction(v) => { - let v = BuiltInWindowFunction::from_i32(*v) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?; - struct_ser.serialize_field("builtInFunction", &v)?; - } - window_expr_node::WindowFunction::Udaf(v) => { - struct_ser.serialize_field("udaf", v)?; - } - window_expr_node::WindowFunction::Udwf(v) => { - struct_ser.serialize_field("udwf", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for WindowExprNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "expr", - "partition_by", - "partitionBy", - "order_by", - "orderBy", - "window_frame", - "windowFrame", - "aggr_function", - "aggrFunction", - "built_in_function", - "builtInFunction", - "udaf", - "udwf", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Expr, - PartitionBy, - OrderBy, - WindowFrame, - AggrFunction, - BuiltInFunction, - Udaf, - Udwf, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "expr" => Ok(GeneratedField::Expr), - "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy), - "orderBy" | "order_by" => Ok(GeneratedField::OrderBy), - "windowFrame" | "window_frame" => Ok(GeneratedField::WindowFrame), - "aggrFunction" | "aggr_function" => Ok(GeneratedField::AggrFunction), - "builtInFunction" | "built_in_function" => Ok(GeneratedField::BuiltInFunction), - "udaf" => Ok(GeneratedField::Udaf), - "udwf" => Ok(GeneratedField::Udwf), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WindowExprNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.WindowExprNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut expr__ = None; - let mut partition_by__ = None; - let mut order_by__ = None; - let mut window_frame__ = None; - let mut window_function__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Expr => { - if expr__.is_some() { - return Err(serde::de::Error::duplicate_field("expr")); - } - expr__ = map.next_value()?; - } - GeneratedField::PartitionBy => { - if partition_by__.is_some() { - return Err(serde::de::Error::duplicate_field("partitionBy")); - } - partition_by__ = Some(map.next_value()?); - } - GeneratedField::OrderBy => { - if order_by__.is_some() { - return Err(serde::de::Error::duplicate_field("orderBy")); - } - order_by__ = Some(map.next_value()?); - } - GeneratedField::WindowFrame => { - if window_frame__.is_some() { - return Err(serde::de::Error::duplicate_field("windowFrame")); - } - window_frame__ = map.next_value()?; - } - GeneratedField::AggrFunction => { - if window_function__.is_some() { - return Err(serde::de::Error::duplicate_field("aggrFunction")); - } - window_function__ = map.next_value::<::std::option::Option>()?.map(|x| window_expr_node::WindowFunction::AggrFunction(x as i32)); - } - GeneratedField::BuiltInFunction => { - if window_function__.is_some() { - return Err(serde::de::Error::duplicate_field("builtInFunction")); - } - window_function__ = map.next_value::<::std::option::Option>()?.map(|x| window_expr_node::WindowFunction::BuiltInFunction(x as i32)); - } - GeneratedField::Udaf => { - if window_function__.is_some() { - return Err(serde::de::Error::duplicate_field("udaf")); - } - window_function__ = map.next_value::<::std::option::Option<_>>()?.map(window_expr_node::WindowFunction::Udaf); - } - GeneratedField::Udwf => { - if window_function__.is_some() { - return Err(serde::de::Error::duplicate_field("udwf")); - } - window_function__ = map.next_value::<::std::option::Option<_>>()?.map(window_expr_node::WindowFunction::Udwf); - } - } - } - Ok(WindowExprNode { - expr: expr__, - partition_by: partition_by__.unwrap_or_default(), - order_by: order_by__.unwrap_or_default(), - window_frame: window_frame__, - window_function: window_function__, - }) - } - } - deserializer.deserialize_struct("datafusion.WindowExprNode", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for WindowFrame { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.window_frame_units != 0 { - len += 1; - } - if self.start_bound.is_some() { - len += 1; - } - if self.end_bound.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrame", len)?; - if self.window_frame_units != 0 { - let v = WindowFrameUnits::from_i32(self.window_frame_units) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_units)))?; - struct_ser.serialize_field("windowFrameUnits", &v)?; - } - if let Some(v) = self.start_bound.as_ref() { - struct_ser.serialize_field("startBound", v)?; - } - if let Some(v) = self.end_bound.as_ref() { - match v { - window_frame::EndBound::Bound(v) => { - struct_ser.serialize_field("bound", v)?; - } - } - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for WindowFrame { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "window_frame_units", - "windowFrameUnits", - "start_bound", - "startBound", - "bound", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - WindowFrameUnits, - StartBound, - Bound, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "windowFrameUnits" | "window_frame_units" => Ok(GeneratedField::WindowFrameUnits), - "startBound" | "start_bound" => Ok(GeneratedField::StartBound), - "bound" => Ok(GeneratedField::Bound), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WindowFrame; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.WindowFrame") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut window_frame_units__ = None; - let mut start_bound__ = None; - let mut end_bound__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::WindowFrameUnits => { - if window_frame_units__.is_some() { - return Err(serde::de::Error::duplicate_field("windowFrameUnits")); - } - window_frame_units__ = Some(map.next_value::()? as i32); - } - GeneratedField::StartBound => { - if start_bound__.is_some() { - return Err(serde::de::Error::duplicate_field("startBound")); - } - start_bound__ = map.next_value()?; - } - GeneratedField::Bound => { - if end_bound__.is_some() { - return Err(serde::de::Error::duplicate_field("bound")); - } - end_bound__ = map.next_value::<::std::option::Option<_>>()?.map(window_frame::EndBound::Bound) -; - } - } - } - Ok(WindowFrame { - window_frame_units: window_frame_units__.unwrap_or_default(), - start_bound: start_bound__, - end_bound: end_bound__, - }) - } - } - deserializer.deserialize_struct("datafusion.WindowFrame", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for WindowFrameBound { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.window_frame_bound_type != 0 { - len += 1; - } - if self.bound_value.is_some() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.WindowFrameBound", len)?; - if self.window_frame_bound_type != 0 { - let v = WindowFrameBoundType::from_i32(self.window_frame_bound_type) - .ok_or_else(|| serde::ser::Error::custom(format!("Invalid variant {}", self.window_frame_bound_type)))?; - struct_ser.serialize_field("windowFrameBoundType", &v)?; - } - if let Some(v) = self.bound_value.as_ref() { - struct_ser.serialize_field("boundValue", v)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for WindowFrameBound { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "window_frame_bound_type", - "windowFrameBoundType", - "bound_value", - "boundValue", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - WindowFrameBoundType, - BoundValue, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "windowFrameBoundType" | "window_frame_bound_type" => Ok(GeneratedField::WindowFrameBoundType), - "boundValue" | "bound_value" => Ok(GeneratedField::BoundValue), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WindowFrameBound; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.WindowFrameBound") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut window_frame_bound_type__ = None; - let mut bound_value__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::WindowFrameBoundType => { - if window_frame_bound_type__.is_some() { - return Err(serde::de::Error::duplicate_field("windowFrameBoundType")); - } - window_frame_bound_type__ = Some(map.next_value::()? as i32); - } - GeneratedField::BoundValue => { - if bound_value__.is_some() { - return Err(serde::de::Error::duplicate_field("boundValue")); - } - bound_value__ = map.next_value()?; - } - } - } - Ok(WindowFrameBound { - window_frame_bound_type: window_frame_bound_type__.unwrap_or_default(), - bound_value: bound_value__, - }) - } - } - deserializer.deserialize_struct("datafusion.WindowFrameBound", FIELDS, GeneratedVisitor) - } -} -impl serde::Serialize for WindowFrameBoundType { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::CurrentRow => "CURRENT_ROW", - Self::Preceding => "PRECEDING", - Self::Following => "FOLLOWING", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for WindowFrameBoundType { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "CURRENT_ROW", - "PRECEDING", - "FOLLOWING", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WindowFrameBoundType; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(WindowFrameBoundType::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(WindowFrameBoundType::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "CURRENT_ROW" => Ok(WindowFrameBoundType::CurrentRow), - "PRECEDING" => Ok(WindowFrameBoundType::Preceding), - "FOLLOWING" => Ok(WindowFrameBoundType::Following), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for WindowFrameUnits { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - let variant = match self { - Self::Rows => "ROWS", - Self::Range => "RANGE", - Self::Groups => "GROUPS", - }; - serializer.serialize_str(variant) - } -} -impl<'de> serde::Deserialize<'de> for WindowFrameUnits { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "ROWS", - "RANGE", - "GROUPS", - ]; - - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WindowFrameUnits; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - fn visit_i64(self, v: i64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(WindowFrameUnits::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self) - }) - } - - fn visit_u64(self, v: u64) -> std::result::Result - where - E: serde::de::Error, - { - use std::convert::TryFrom; - i32::try_from(v) - .ok() - .and_then(WindowFrameUnits::from_i32) - .ok_or_else(|| { - serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self) - }) - } - - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "ROWS" => Ok(WindowFrameUnits::Rows), - "RANGE" => Ok(WindowFrameUnits::Range), - "GROUPS" => Ok(WindowFrameUnits::Groups), - _ => Err(serde::de::Error::unknown_variant(value, FIELDS)), - } - } - } - deserializer.deserialize_any(GeneratedVisitor) - } -} -impl serde::Serialize for WindowNode { - #[allow(deprecated)] - fn serialize(&self, serializer: S) -> std::result::Result - where - S: serde::Serializer, - { - use serde::ser::SerializeStruct; - let mut len = 0; - if self.input.is_some() { - len += 1; - } - if !self.window_expr.is_empty() { - len += 1; - } - let mut struct_ser = serializer.serialize_struct("datafusion.WindowNode", len)?; - if let Some(v) = self.input.as_ref() { - struct_ser.serialize_field("input", v)?; - } - if !self.window_expr.is_empty() { - struct_ser.serialize_field("windowExpr", &self.window_expr)?; - } - struct_ser.end() - } -} -impl<'de> serde::Deserialize<'de> for WindowNode { - #[allow(deprecated)] - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - const FIELDS: &[&str] = &[ - "input", - "window_expr", - "windowExpr", - ]; - - #[allow(clippy::enum_variant_names)] - enum GeneratedField { - Input, - WindowExpr, - } - impl<'de> serde::Deserialize<'de> for GeneratedField { - fn deserialize(deserializer: D) -> std::result::Result - where - D: serde::Deserializer<'de>, - { - struct GeneratedVisitor; - - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = GeneratedField; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(formatter, "expected one of: {:?}", &FIELDS) - } - - #[allow(unused_variables)] - fn visit_str(self, value: &str) -> std::result::Result - where - E: serde::de::Error, - { - match value { - "input" => Ok(GeneratedField::Input), - "windowExpr" | "window_expr" => Ok(GeneratedField::WindowExpr), - _ => Err(serde::de::Error::unknown_field(value, FIELDS)), - } - } - } - deserializer.deserialize_identifier(GeneratedVisitor) - } - } - struct GeneratedVisitor; - impl<'de> serde::de::Visitor<'de> for GeneratedVisitor { - type Value = WindowNode; - - fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - formatter.write_str("struct datafusion.WindowNode") - } - - fn visit_map(self, mut map: V) -> std::result::Result - where - V: serde::de::MapAccess<'de>, - { - let mut input__ = None; - let mut window_expr__ = None; - while let Some(k) = map.next_key()? { - match k { - GeneratedField::Input => { - if input__.is_some() { - return Err(serde::de::Error::duplicate_field("input")); - } - input__ = map.next_value()?; - } - GeneratedField::WindowExpr => { - if window_expr__.is_some() { - return Err(serde::de::Error::duplicate_field("windowExpr")); - } - window_expr__ = Some(map.next_value()?); - } - } - } - Ok(WindowNode { - input: input__, - window_expr: window_expr__.unwrap_or_default(), - }) - } - } - deserializer.deserialize_struct("datafusion.WindowNode", FIELDS, GeneratedVisitor) - } -}