Ticket #2068: 0001-ticket-2068-Extend-binary-induced-operations-with-op .patch

File 0001-ticket-2068-Extend-binary-induced-operations-with-op .patch, 25.9 KB (added by Dimitar Misev, 5 years ago)

current patch

  • catalogmgr/ops.cc 

    From 267e9b7db2745adaa215b26d959498791f1c6811 Mon Sep 17 00:00:00 2001
From: Alexandru Hambasan <alex.hambasan2000@gmail.com>
Date: Tue, 2 Jul 2019 12:04:12 +0200
Subject: [PATCH] ticket:2068 - Extend binary induced operations with option to
 indicate null values treatment

---
 catalogmgr/ops.cc          | 601 ++++++++++++++++++++++++++++++++-----
 catalogmgr/ops.hh          |   4 +-
 qlparser/qtbinaryinduce.cc |   2 +-
 3 files changed, 535 insertions(+), 72 deletions(-)

diff --git a/catalogmgr/ops.cc b/catalogmgr/ops.cc
index f053331c1..a283cfd10 100644
    a b OpNOTBool::operator()(char *res, const char *op)  
    15641564
    15651565BinaryOp::BinaryOp(const BaseType *newResType, const BaseType *newOp1Type,
    15661566                   const BaseType *newOp2Type, size_t newResOff,
    1567                    size_t newOp1Off, size_t newOp2Off)
     1567                   size_t newOp1Off, size_t newOp2Off, bool nullAsIdentity)
    15681568    :  NullValuesHandler(), op1Type(newOp1Type), op2Type(newOp2Type), resType(newResType),
    15691569       resOff(newResOff), op1Off(newOp1Off), op2Off(newOp2Off)
    15701570{
     1571    this->treatNullAsIdentity = nullAsIdentity;
    15711572}
    15721573
    15731574void
    … … OpPLUSCULong::operator()(char *res, const char *op1, const char *op2)  
    16111612
    16121613    if (isNull(longOp1))
    16131614    {
    1614         longRes = longOp1;
     1615        if (treatNullAsIdentity)
     1616        {
     1617            longRes = longOp2;
     1618        }
     1619        else
     1620        {
     1621            longRes = longOp1;
     1622        }
    16151623    }
    16161624    else if (isNull(longOp2))
    16171625    {
    1618         longRes = longOp2;
     1626        if (treatNullAsIdentity)
     1627        {
     1628            longRes = longOp1;
     1629        }
     1630        else {
     1631            longRes = longOp2;
     1632        }
    16191633    }
    16201634    else
    16211635    {
    … … OpPLUSULong::operator()(char *res, const char *op1, const char *op2)  
    16461660{
    16471661    if (isNull(*(r_ULong *)(const_cast<char *>(op1) + op1Off)))
    16481662    {
    1649         *(r_ULong *)(res + resOff) = *(r_ULong *)(const_cast<char *>(op1) + op1Off);
     1663        if (treatNullAsIdentity)
     1664        {
     1665          *(r_ULong *)(res + resOff) = *(r_ULong *)(const_cast<char *>(op2) + op1Off);   
     1666        }
     1667        else {
     1668            *(r_ULong *)(res + resOff) = *(r_ULong *)(const_cast<char *>(op1) + op1Off);
     1669        }
    16501670    }
    16511671    else if (isNull(*(r_ULong *)(const_cast<char *>(op2) + op2Off)))
    16521672    {
    1653         *(r_ULong *)(res + resOff) = *(r_ULong *)(const_cast<char *>(op2) + op2Off);
     1673        if (treatNullAsIdentity)
     1674        {
     1675             *(r_ULong *)(res + resOff) = *(r_ULong *)(const_cast<char *>(op1) + op1Off);
     1676        }
     1677        else {
     1678            *(r_ULong *)(res + resOff) = *(r_ULong *)(const_cast<char *>(op2) + op2Off);
     1679        }
    16541680    }
    16551681    else
    16561682    {
    … … OpMINUSCULong::operator()(char *res, const char *op1, const char *op2)  
    18201846
    18211847    if (isNull(longOp1))
    18221848    {
    1823         longRes = longOp1;
     1849        if (treatNullAsIdentity)
     1850        {
     1851            longRes = longOp2;
     1852        }
     1853        else
     1854        {
     1855            longRes = longOp1;
     1856        }
    18241857    }
    18251858    else if (isNull(longOp2))
    18261859    {
    1827         longRes = longOp2;
     1860        if (treatNullAsIdentity)
     1861        {
     1862            longRes = longOp1;
     1863        }
     1864        else
     1865        {
     1866            longRes = longOp2;
     1867        }
     1868       
    18281869    }
    18291870    else
    18301871    {
    … … OpDIVCULong::operator()(char *res, const char *op1, const char *op2)  
    18541895
    18551896    if (isNull(longOp1))
    18561897    {
    1857         longRes = longOp1;
     1898        if (treatNullAsIdentity)
     1899        {
     1900            longRes = longOp2;
     1901        }
     1902        else
     1903        {
     1904            longRes = longOp1;
     1905        }
    18581906    }
    18591907    else if (isNull(longOp2))
    18601908    {
    1861         longRes = longOp2;
     1909        if (treatNullAsIdentity)
     1910        {
     1911            longRes = longOp1;
     1912        }
     1913        else
     1914        {
     1915            longRes = longOp2;
     1916        }
    18621917    }
    18631918    else
    18641919    {
    … … OpMODCULong::operator()(char *res, const char *op1, const char *op2)  
    18951950
    18961951    if (isNull(longOp1))
    18971952    {
    1898         longRes = longOp1;
     1953        if (treatNullAsIdentity)
     1954        {
     1955            longRes = longOp2;
     1956        }
     1957        else
     1958        {
     1959            longRes = longOp1;
     1960        }
    18991961    }
    19001962    else if (isNull(longOp2))
    19011963    {
    1902         longRes = longOp2;
     1964        if (treatNullAsIdentity)
     1965        {
     1966            longRes = longOp1;
     1967        }
     1968        else
     1969        {
     1970            longRes = longOp2;
     1971        }
    19031972    }
    19041973    else
    19051974    {
    … … OpMULTCULong::operator()(char *res, const char *op1, const char *op2)  
    19362005
    19372006    if (isNull(longOp1))
    19382007    {
    1939         longRes = longOp1;
     2008        if (treatNullAsIdentity)
     2009        {
     2010            longRes = longOp2;
     2011        }
     2012        else
     2013        {
     2014            longRes = longOp1;
     2015        }
    19402016    }
    19412017    else if (isNull(longOp2))
    19422018    {
    1943         longRes = longOp2;
     2019        if (treatNullAsIdentity)
     2020        {
     2021            longRes = longOp1;
     2022        }
     2023        else
     2024        {
     2025            longRes = longOp2;
     2026        }
    19442027    }
    19452028    else
    19462029    {
    … … OpANDCULong::operator()(char *res, const char *op1, const char *op2)  
    19782061
    19792062    if (isNull(longOp1))
    19802063    {
    1981         longRes = longOp1;
     2064        if (treatNullAsIdentity)
     2065        {
     2066            longRes = longOp2;
     2067        }
     2068        else
     2069        {
     2070            longRes = longOp1;
     2071        }
    19822072    }
    19832073    else if (isNull(longOp2))
    19842074    {
    1985         longRes = longOp2;
     2075        if (treatNullAsIdentity)
     2076        {
     2077            longRes = longOp1;
     2078        }
     2079        else
     2080        {
     2081            longRes = longOp2;
     2082        }
    19862083    }
    19872084    else
    19882085    {
    … … OpANDBool::operator()(char *res, const char *op1, const char *op2)  
    20142111
    20152112    if (isNull(*(op1 + op1Off)))
    20162113    {
    2017         *(res + resOff) = *(op1 + op1Off);
     2114        if (treatNullAsIdentity)
     2115        {
     2116            *(res + resOff) = *(op2 + op2Off);
     2117        }
     2118        else
     2119        {
     2120            *(res + resOff) = *(op1 + op1Off);
     2121        }
    20182122    }
    20192123    else if (isNull(*(op2 + op2Off)))
    20202124    {
    2021         *(res + resOff) = *(op2 + op2Off);
     2125        if (treatNullAsIdentity)
     2126        {
     2127            *(res + resOff) = *(op1 + op1Off);
     2128        }
     2129        else
     2130        {
     2131            *(res + resOff) = *(op2 + op2Off);
     2132        }
    20222133    }
    20232134    else
    20242135    {
    … … OpORCULong::operator()(char *res, const char *op1, const char *op2)  
    20532164
    20542165    if (isNull(longOp1))
    20552166    {
    2056         longRes = longOp1;
     2167        if (treatNullAsIdentity)
     2168        {
     2169            longRes = longOp2;
     2170        }
     2171        else
     2172        {
     2173            longRes = longOp1;
     2174        }
    20572175    }
    20582176    else if (isNull(longOp2))
    20592177    {
    2060         longRes = longOp2;
     2178        if (treatNullAsIdentity)
     2179        {
     2180            longRes = longOp1;
     2181        }
     2182        else
     2183        {
     2184            longRes = longOp2;
     2185        }
    20612186    }
    20622187    else
    20632188    {
    … … OpORBool::operator()(char *res, const char *op1, const char *op2)  
    20892214
    20902215    if (isNull(*(op1 + op1Off)))
    20912216    {
    2092         *(res + resOff) = *(op1 + op1Off);
     2217        if (treatNullAsIdentity)
     2218        {
     2219            *(res + resOff) = *(op2 + op2Off);
     2220        }
     2221        else
     2222        {
     2223            *(res + resOff) = *(op1 + op1Off);
     2224        }
    20932225    }
    20942226    else if (isNull(*(op2 + op2Off)))
    20952227    {
    2096         *(res + resOff) = *(op2 + op2Off);
     2228        if (treatNullAsIdentity)
     2229        {
     2230            *(res + resOff) = *(op1 + op1Off);
     2231        }
     2232        else
     2233        {
     2234            *(res + resOff) = *(op2 + op2Off);
     2235        }
    20972236    }
    20982237    else
    20992238    {
    … … OpXORCULong::operator()(char *res, const char *op1, const char *op2)  
    21282267
    21292268    if (isNull(longOp1))
    21302269    {
    2131         longRes = longOp1;
     2270        if (treatNullAsIdentity)
     2271        {
     2272            longRes = longOp2;
     2273        }
     2274        else
     2275        {
     2276            longRes = longOp1;
     2277        }
    21322278    }
    21332279    else if (isNull(longOp2))
    21342280    {
    2135         longRes = longOp2;
     2281        if (treatNullAsIdentity)
     2282        {
     2283            longRes = longOp1;
     2284        }
     2285        else
     2286        {
     2287            longRes = longOp2;
     2288        }
    21362289    }
    21372290    else
    21382291    {
    … … OpXORBool::operator()(char *res, const char *op1, const char *op2)  
    21562309
    21572310    if (isNull(*(op1 + op1Off)))
    21582311    {
    2159         *(res + resOff) = *(op1 + op1Off);
     2312        if (treatNullAsIdentity)
     2313        {
     2314            *(res + resOff) = *(op2 + op2Off);
     2315        }
     2316        else
     2317        {
     2318            *(res + resOff) = *(op1 + op1Off);
     2319        }
    21602320    }
    21612321    else if (isNull(*(op2 + op2Off)))
    21622322    {
    2163         *(res + resOff) = *(op2 + op2Off);
     2323        if (treatNullAsIdentity)
     2324        {
     2325            *(res + resOff) = *(op1 + op1Off);
     2326        }
     2327        else
     2328        {
     2329            *(res + resOff) = *(op2 + op2Off);
     2330        }
    21642331    }
    21652332    else
    21662333    {
    … … OpPLUSCLong::operator()(char *res, const char *op1, const char *op2)  
    21892356
    21902357    if (isNull(longOp1))
    21912358    {
    2192         longRes = longOp1;
     2359        if (treatNullAsIdentity)
     2360        {
     2361            longRes = longOp2;
     2362        }
     2363        else
     2364        {
     2365            longRes = longOp1;
     2366        }
    21932367    }
    21942368    else if (isNull(longOp2))
    21952369    {
    2196         longRes = longOp2;
     2370        if (treatNullAsIdentity)
     2371        {
     2372            longRes = longOp1;
     2373        }
     2374        else
     2375        {
     2376            longRes = longOp2;
     2377        }
    21972378    }
    21982379    else
    21992380    {
    … … OpMINUSCLong::operator()(char *res, const char *op1, const char *op2)  
    23022483
    23032484    if (isNull(longOp1))
    23042485    {
    2305         longRes = longOp1;
     2486        if (treatNullAsIdentity)
     2487        {
     2488            longRes = longOp2;
     2489        }
     2490        else
     2491        {
     2492            longRes = longOp1;
     2493        }
    23062494    }
    23072495    else if (isNull(longOp2))
    23082496    {
    2309         longRes = longOp2;
     2497        if (treatNullAsIdentity)
     2498        {
     2499            longRes = longOp1;
     2500        }
     2501        else
     2502        {
     2503            longRes = longOp2;
     2504        }
    23102505    }
    23112506    else
    23122507    {
    … … OpDIVCLong::operator()(char *res, const char *op1, const char *op2)  
    23362531
    23372532    if (isNull(longOp1))
    23382533    {
    2339         longRes = longOp1;
     2534        if (treatNullAsIdentity)
     2535        {
     2536            longRes = longOp2;
     2537        }
     2538        else
     2539        {
     2540            longRes = longOp1;
     2541        }
    23402542    }
    23412543    else if (isNull(longOp2))
    23422544    {
    2343         longRes = longOp2;
     2545        if (treatNullAsIdentity)
     2546        {
     2547            longRes = longOp1;
     2548        }
     2549        else
     2550        {
     2551            longRes = longOp2;
     2552        }
    23442553    }
    23452554    else
    23462555    {
    … … OpMODCLong::operator()(char *res, const char *op1, const char *op2)  
    23772586
    23782587    if (isNull(longOp1))
    23792588    {
    2380         longRes = longOp1;
     2589        if (treatNullAsIdentity)
     2590        {
     2591            longRes = longOp2;
     2592        }
     2593        else
     2594        {
     2595            longRes = longOp1;
     2596        }
    23812597    }
    23822598    else if (isNull(longOp2))
    23832599    {
    2384         longRes = longOp2;
     2600        if (treatNullAsIdentity)
     2601        {
     2602            longRes = longOp1;
     2603        }
     2604        else
     2605        {
     2606            longRes = longOp2;
     2607        }
    23852608    }
    23862609    else
    23872610    {
    … … OpMULTCLong::operator()(char *res, const char *op1, const char *op2)  
    24182641
    24192642    if (isNull(longOp1))
    24202643    {
    2421         longRes = longOp1;
     2644        if (treatNullAsIdentity)
     2645        {
     2646            longRes = longOp2;
     2647        }
     2648        else
     2649        {
     2650            longRes = longOp1;
     2651        }
    24222652    }
    24232653    else if (isNull(longOp2))
    24242654    {
    2425         longRes = longOp2;
     2655        if (treatNullAsIdentity)
     2656        {
     2657            longRes = longOp1;
     2658        }
     2659        else
     2660        {
     2661            longRes = longOp2;
     2662        }
    24262663    }
    24272664    else
    24282665    {
    … … OpANDCLong::operator()(char *res, const char *op1, const char *op2)  
    24602697
    24612698    if (isNull(longOp1))
    24622699    {
    2463         longRes = longOp1;
     2700        if (treatNullAsIdentity)
     2701        {
     2702            longRes = longOp2;
     2703        }
     2704        else
     2705        {
     2706            longRes = longOp1;
     2707        }
    24642708    }
    24652709    else if (isNull(longOp2))
    24662710    {
    2467         longRes = longOp2;
     2711        if (treatNullAsIdentity)
     2712        {
     2713            longRes = longOp1;
     2714        }
     2715        else
     2716        {
     2717            longRes = longOp2;
     2718        }
    24682719    }
    24692720    else
    24702721    {
    … … OpORCLong::operator()(char *res, const char *op1, const char *op2)  
    25022753
    25032754    if (isNull(longOp1))
    25042755    {
    2505         longRes = longOp1;
     2756        if (treatNullAsIdentity)
     2757        {
     2758            longRes = longOp2;
     2759        }
     2760        else
     2761        {
     2762            longRes = longOp1;
     2763        }
    25062764    }
    25072765    else if (isNull(longOp2))
    25082766    {
    2509         longRes = longOp2;
     2767        if (treatNullAsIdentity)
     2768        {
     2769            longRes = longOp1;
     2770        }
     2771        else
     2772        {
     2773            longRes = longOp2;
     2774        }
    25102775    }
    25112776    else
    25122777    {
    … … OpXORCLong::operator()(char *res, const char *op1, const char *op2)  
    25442809
    25452810    if (isNull(longOp1))
    25462811    {
    2547         longRes = longOp1;
     2812        if (treatNullAsIdentity)
     2813        {
     2814            longRes = longOp2;
     2815        }
     2816        else
     2817        {
     2818            longRes = longOp1;
     2819        }
    25482820    }
    25492821    else if (isNull(longOp2))
    25502822    {
    2551         longRes = longOp2;
     2823        if (treatNullAsIdentity)
     2824        {
     2825            longRes = longOp1;
     2826        }
     2827        else
     2828        {
     2829            longRes = longOp2;
     2830        }
    25522831    }
    25532832    else
    25542833    {
    … … OpPLUSCDouble::operator()(char *res, const char *op1, const char *op2)  
    25782857
    25792858    if (isNull(doubleOp1))
    25802859    {
    2581         doubleRes = doubleOp1;
     2860        if (treatNullAsIdentity)
     2861        {
     2862            doubleRes = doubleOp2;
     2863        }
     2864        else
     2865        {
     2866            doubleRes = doubleOp2;
     2867        }
    25822868    }
    25832869    else if (isNull(doubleOp2))
    25842870    {
    2585         doubleRes = doubleOp2;
     2871        if (treatNullAsIdentity)
     2872        {
     2873            doubleRes = doubleOp1;
     2874        }
     2875        else
     2876        {
     2877            doubleRes = doubleOp2;
     2878        }
    25862879    }
    25872880    else
    25882881    {
    … … OpMINUSCDouble::operator()(char *res, const char *op1, const char *op2)  
    26912984
    26922985    if (isNull(doubleOp1))
    26932986    {
    2694         doubleRes = doubleOp1;
     2987        if (treatNullAsIdentity)
     2988        {
     2989            doubleRes = doubleOp2;
     2990        }
     2991        else
     2992        {
     2993            doubleRes = doubleOp2;
     2994        }
    26952995    }
    26962996    else if (isNull(doubleOp2))
    26972997    {
    2698         doubleRes = doubleOp2;
     2998        if (treatNullAsIdentity)
     2999        {
     3000            doubleRes = doubleOp1;
     3001        }
     3002        else
     3003        {
     3004            doubleRes = doubleOp2;
     3005        }
    26993006    }
    27003007    else
    27013008    {
    … … OpDIVCDouble::operator()(char *res, const char *op1, const char *op2)  
    27253032
    27263033    if (isNull(doubleOp1))
    27273034    {
    2728         doubleRes = doubleOp1;
     3035        if (treatNullAsIdentity)
     3036        {
     3037            doubleRes = doubleOp2;
     3038        }
     3039        else
     3040        {
     3041            doubleRes = doubleOp2;
     3042        }
    27293043    }
    27303044    else if (isNull(doubleOp2))
    27313045    {
    2732         doubleRes = doubleOp2;
     3046        if (treatNullAsIdentity)
     3047        {
     3048            doubleRes = doubleOp1;
     3049        }
     3050        else
     3051        {
     3052            doubleRes = doubleOp2;
     3053        }
    27333054    }
    27343055    else
    27353056    {
    … … OpMULTCDouble::operator()(char *res, const char *op1, const char *op2)  
    27603081
    27613082    if (isNull(doubleOp1))
    27623083    {
    2763         doubleRes = doubleOp1;
     3084        if (treatNullAsIdentity)
     3085        {
     3086            doubleRes = doubleOp2;
     3087        }
     3088        else
     3089        {
     3090            doubleRes = doubleOp2;
     3091        }
    27643092    }
    27653093    else if (isNull(doubleOp2))
    27663094    {
    2767         doubleRes = doubleOp2;
     3095        if (treatNullAsIdentity)
     3096        {
     3097            doubleRes = doubleOp1;
     3098        }
     3099        else
     3100        {
     3101            doubleRes = doubleOp2;
     3102        }
    27683103    }
    27693104    else
    27703105    {
    … … OpPLUSChar::operator()(char *res, const char *op1, const char *op2)  
    46184953{
    46194954    if (isNull(*(unsigned char *)(const_cast<char *>(op1) + op1Off)))
    46204955    {
    4621         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     4956        if (treatNullAsIdentity)
     4957        {
     4958            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     4959        }
     4960        else
     4961        {
     4962            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     4963        }
    46224964    }
    46234965    else if (isNull(*(unsigned char *)(const_cast<char *>(op2)  + op2Off)))
    46244966    {
    4625         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     4967        if (treatNullAsIdentity)
     4968        {
     4969            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     4970        }
     4971        else
     4972        {
     4973            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     4974        }
    46264975    }
    46274976    else
    46284977    {
    … … OpMAX_BINARYChar::operator()(char *res, const char *op1, const char *op2)  
    46545003{
    46555004    if (isNull(*(unsigned char *)(const_cast<char *>(op1) + op1Off)))
    46565005    {
    4657         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5006        if (treatNullAsIdentity)
     5007        {
     5008            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5009        }
     5010        else
     5011        {
     5012            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5013        }
    46585014    }
    46595015    else if (isNull(*(unsigned char *)(const_cast<char *>(op2)  + op2Off)))
    46605016    {
    4661         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5017        if (treatNullAsIdentity)
     5018        {
     5019            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5020        }
     5021        else
     5022        {
     5023            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5024        }
    46625025    }
    46635026    else if (*(unsigned char *)(const_cast<char *>(op1)  + op1Off) > *(unsigned char *)(const_cast<char *>(op2)  + op2Off))
    46645027    {
    … … OpMIN_BINARYChar::operator()(char *res, const char *op1, const char *op2)  
    46935056{
    46945057    if (isNull(*(unsigned char *)(const_cast<char *>(op1) + op1Off)))
    46955058    {
    4696         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5059        if (treatNullAsIdentity)
     5060        {
     5061            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op1Off);
     5062        }
     5063        else
     5064        {
     5065            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5066        }
    46975067    }
    46985068    else if (isNull(*(unsigned char *)(const_cast<char *>(op2)  + op2Off)))
    46995069    {
    4700         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5070        if (treatNullAsIdentity)
     5071        {
     5072            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5073        }
     5074        else
     5075        {
     5076            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5077        }
    47015078    }
    47025079    else if (*(unsigned char *)(const_cast<char *>(op1)  + op1Off) < * (unsigned char *)(const_cast<char *>(op2)  + op2Off))
    47035080    {
    … … OpMINUSChar::OpMINUSChar(const BaseType *newResType, const BaseType *newOp1Type,  
    47305107void
    47315108OpMINUSChar::operator()(char *res, const char *op1, const char *op2)
    47325109{
    4733     if (isNull(*(unsigned char *)(const_cast<char *>(op1)  + op1Off)))
     5110    if (isNull(*(unsigned char *)(const_cast<char *>(op1) + op1Off)))
    47345111    {
    4735         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1) + op1Off);
     5112        if (treatNullAsIdentity)
     5113        {
     5114            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op1Off);
     5115        }
     5116        else
     5117        {
     5118            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5119        }
    47365120    }
    47375121    else if (isNull(*(unsigned char *)(const_cast<char *>(op2)  + op2Off)))
    47385122    {
    4739         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5123        if (treatNullAsIdentity)
     5124        {
     5125            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5126        }
     5127        else
     5128        {
     5129            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5130        }
    47405131    }
    47415132    else
    47425133    {
    … … OpDIVChar::operator()(char *res, const char *op1, const char *op2)  
    47625153{
    47635154    if (isNull(*(unsigned char *)(const_cast<char *>(op1) + op1Off)))
    47645155    {
    4765         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1) + op1Off);
     5156        if (treatNullAsIdentity)
     5157        {
     5158            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op1Off);
     5159        }
     5160        else
     5161        {
     5162            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5163        }
    47665164    }
    47675165    else if (isNull(*(unsigned char *)(const_cast<char *>(op2)  + op2Off)))
    47685166    {
    4769         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5167        if (treatNullAsIdentity)
     5168        {
     5169            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5170        }
     5171        else
     5172        {
     5173            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5174        }
    47705175    }
    47715176    else
    47725177    {
    … … OpMODChar::operator()(char *res, const char *op1, const char *op2)  
    47995204{
    48005205    if (isNull(*(unsigned char *)(const_cast<char *>(op1) + op1Off)))
    48015206    {
    4802         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1) + op1Off);
     5207        if (treatNullAsIdentity)
     5208        {
     5209            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op1Off);
     5210        }
     5211        else
     5212        {
     5213            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5214        }
    48035215    }
    4804     else if (isNull(*(unsigned char *)(const_cast<char *>(op2) + op2Off)))
     5216    else if (isNull(*(unsigned char *)(const_cast<char *>(op2)  + op2Off)))
    48055217    {
    4806         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2) + op2Off);
     5218        if (treatNullAsIdentity)
     5219        {
     5220            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5221        }
     5222        else
     5223        {
     5224            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5225        }
    48075226    }
    48085227    else
    48095228    {
    … … OpMULTChar::operator()(char *res, const char *op1, const char *op2)  
    48365255{
    48375256    if (isNull(*(unsigned char *)(const_cast<char *>(op1) + op1Off)))
    48385257    {
    4839         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1) + op1Off);
     5258        if (treatNullAsIdentity)
     5259        {
     5260            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op1Off);
     5261        }
     5262        else
     5263        {
     5264            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5265        }
    48405266    }
    4841     else if (isNull(*(unsigned char *)(const_cast<char *>(op2) + op2Off)))
     5267    else if (isNull(*(unsigned char *)(const_cast<char *>(op2)  + op2Off)))
    48425268    {
    4843         *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2) + op2Off);
     5269        if (treatNullAsIdentity)
     5270        {
     5271            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op1)  + op1Off);
     5272        }
     5273        else
     5274        {
     5275            *(unsigned char *)(res + resOff) = *(unsigned char *)(const_cast<char *>(op2)  + op2Off);
     5276        }
    48445277    }
    48455278    else
    48465279    {
    … … void OpPLUSComplex::operator()(char *res, const char *op1, const char *op2)  
    53175750
    53185751    if (isNull(op1Re))
    53195752    {
    5320         resRe = op1Re;
     5753        if (treatNullAsIdentity)
     5754        {
     5755            resRe = op2Re;
     5756        }
     5757        else
     5758        {
     5759            resRe = op1Re;
     5760        }
    53215761    }
    53225762    else if (isNull(op2Re))
    53235763    {
    5324         resRe = op2Re;
     5764        if (treatNullAsIdentity)
     5765        {
     5766            resRe = op1Re;
     5767        }
     5768        else
     5769        {
     5770            resRe = op2Re;
     5771        }
    53255772    }
    53265773    else
    53275774    {
    … … void OpMINUSComplex::operator()(char *res, const char *op1, const char *op2)  
    55806027
    55816028    if (isNull(op1Re))
    55826029    {
    5583         resRe = op1Re;
     6030        if (treatNullAsIdentity)
     6031        {
     6032            resRe = op2Re;
     6033        }
     6034        else
     6035        {
     6036            resRe = op1Re;
     6037        }
    55846038    }
    55856039    else if (isNull(op2Re))
    55866040    {
    5587         resRe = op2Re;
     6041        if (treatNullAsIdentity)
     6042        {
     6043            resRe = op1Re;
     6044        }
     6045        else
     6046        {
     6047            resRe = op2Re;
     6048        }
    55886049    }
    55896050    else
    55906051    {

  • catalogmgr/ops.hh 

    diff --git a/catalogmgr/ops.hh b/catalogmgr/ops.hh
index 6b9bf15d8..7d81f5a5c 100644
    a b public:  
    875875                and offsets to result and operands (for structs). */
    876876    BinaryOp(const BaseType *newResType, const BaseType *newOp1Type,
    877877             const BaseType *newOp2Type, size_t newResOff = 0,
    878              size_t newOp1Off = 0, size_t newOp2Off = 0);
     878             size_t newOp1Off = 0, size_t newOp2Off = 0, bool nullAsIdentity = false);
    879879    /*@ManMemo: operator to carry out operation on {\tt op1} and
    880880                {\tt op2} with result {\tt res}. */
    881881    virtual void operator()(char *res, const char *op1,
    … … protected:  
    893893    size_t resOff;
    894894    size_t op1Off;
    895895    size_t op2Off;
     896
     897    bool treatNullAsIdentity;
    896898};
    897899
    898900//@ManMemo: Module: {\bf catalogif}.

  • qlparser/qtbinaryinduce.cc 

    diff --git a/qlparser/qtbinaryinduce.cc b/qlparser/qtbinaryinduce.cc
index e8f079a91..138684e49 100644
    a b QtBinaryInduce::computeOp(QtData *operand1, QtData *operand2)  
    7777        MDDObj *op1 = mdd1->getMDDObject();
    7878        MDDObj *op2 = mdd2->getMDDObject();
    7979        const BaseType *resultBaseType = (static_cast<MDDBaseType *>(const_cast<Type *>(dataStreamType.getType())))->getBaseType();
    80         BinaryOp *myOp = Ops::getBinaryOp(opType, resultBaseType, op1->getCellType(), op2->getCellType());
     80        BinaryOp *myOp = Ops::getBinaryOp(opType, resultBaseType, op1->getCellType(), op2->getCellType(), true);
    8181        try
    8282        {
    8383            returnValue = computeBinaryMDDOp(mdd1, mdd2, resultBaseType, myOp);