LCOV - code coverage report
Current view: top level - sql/backends/monet5/UDF/pyapi3 - pytypes3.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 45 125 36.0 %
Date: 2020-06-29 20:00:14 Functions: 9 15 60.0 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2020 MonetDB B.V.
       7             :  */
       8             : 
       9             : #include "monetdb_config.h"
      10             : #include "pytypes.h"
      11             : 
      12           0 : bool PyType_IsInteger(int type)
      13             : {
      14           0 :         switch (type) {
      15             :                 case NPY_BOOL:
      16             :                 case NPY_BYTE:
      17             :                 case NPY_SHORT:
      18             :                 case NPY_INT:
      19             :                 case NPY_LONG:
      20             :                 case NPY_LONGLONG:
      21             :                 case NPY_UBYTE:
      22             :                 case NPY_USHORT:
      23             :                 case NPY_UINT:
      24             :                 case NPY_ULONG:
      25             :                 case NPY_ULONGLONG:
      26             :                         return true;
      27           0 :                 default:
      28           0 :                         return false;
      29             :         }
      30             : }
      31             : 
      32           0 : bool PyType_IsFloat(int type)
      33             : {
      34           0 :         switch (type) {
      35             :                 case NPY_FLOAT16:
      36             :                 case NPY_FLOAT:
      37             :                         return true;
      38           0 :                 default:
      39           0 :                         return false;
      40             :         }
      41             : }
      42             : 
      43           0 : bool PyType_IsDouble(int type)
      44             : {
      45           0 :         switch (type) {
      46             :                 case NPY_DOUBLE:
      47             :                 case NPY_LONGDOUBLE:
      48             :                         return true;
      49           0 :                 default:
      50           0 :                         return false;
      51             :         }
      52             : }
      53             : 
      54           0 : char *PyType_Format(int type)
      55             : {
      56           0 :         switch (type) {
      57             :                 case NPY_BOOL:
      58             :                         return "BOOL";
      59           0 :                 case NPY_BYTE:
      60           0 :                         return "BYTE";
      61           0 :                 case NPY_SHORT:
      62           0 :                         return "SHORT";
      63           0 :                 case NPY_INT:
      64           0 :                         return "INT";
      65           0 :                 case NPY_LONG:
      66           0 :                         return "LONG";
      67           0 :                 case NPY_LONGLONG:
      68           0 :                         return "LONG LONG";
      69           0 :                 case NPY_UBYTE:
      70           0 :                         return "UNSIGNED BYTE";
      71           0 :                 case NPY_USHORT:
      72           0 :                         return "UNSIGNED SHORT";
      73           0 :                 case NPY_UINT:
      74           0 :                         return "UNSIGNED INT";
      75           0 :                 case NPY_ULONG:
      76           0 :                         return "UNSIGNED LONG";
      77           0 :                 case NPY_ULONGLONG:
      78           0 :                         return "UNSIGNED LONG LONG";
      79           0 :                 case NPY_FLOAT16:
      80           0 :                         return "HALF-FLOAT (FLOAT16)";
      81           0 :                 case NPY_FLOAT:
      82           0 :                         return "FLOAT";
      83           0 :                 case NPY_DOUBLE:
      84           0 :                         return "DOUBLE";
      85           0 :                 case NPY_LONGDOUBLE:
      86           0 :                         return "LONG DOUBLE";
      87           0 :                 case NPY_COMPLEX64:
      88           0 :                         return "COMPLEX FLOAT";
      89           0 :                 case NPY_COMPLEX128:
      90           0 :                         return "COMPLEX DOUBLE";
      91           0 :                 case NPY_CLONGDOUBLE:
      92           0 :                         return "COMPLEX LONG DOUBLE";
      93           0 :                 case NPY_DATETIME:
      94           0 :                         return "DATETIME";
      95           0 :                 case NPY_TIMEDELTA:
      96           0 :                         return "TIMEDELTA";
      97           0 :                 case NPY_STRING:
      98           0 :                         return "STRING";
      99           0 :                 case NPY_UNICODE:
     100           0 :                         return "UNICODE STRING";
     101           0 :                 case NPY_OBJECT:
     102           0 :                         return "PYTHON OBJECT";
     103           0 :                 case NPY_VOID:
     104           0 :                         return "VOID";
     105           0 :                 default:
     106           0 :                         return "UNKNOWN";
     107             :         }
     108             : }
     109             : 
     110         349 : char *BatType_Format(int type)
     111             : {
     112         349 :         if (type == TYPE_blob) {
     113             :                 return "BLOB";
     114             :         }
     115         348 :         switch (type) {
     116             :                 case TYPE_void:
     117             :                         return "VOID";
     118          10 :                 case TYPE_bit:
     119          10 :                         return "BOOL";
     120           1 :                 case TYPE_bte:
     121           1 :                         return "TINYINT";
     122           0 :                 case TYPE_sht:
     123           0 :                         return "SHORTINT";
     124         298 :                 case TYPE_int:
     125         298 :                         return "INTEGER";
     126           0 :                 case TYPE_lng:
     127           0 :                         return "LONGINT";
     128           0 :                 case TYPE_flt:
     129           0 :                         return "FLOAT";
     130          10 :                 case TYPE_dbl:
     131          10 :                         return "DOUBLE";
     132          11 :                 case TYPE_str:
     133          11 :                         return "STRING";
     134          11 :                 case TYPE_oid:
     135          11 :                         return "OID";
     136             : #ifdef HAVE_HGE
     137           0 :                 case TYPE_hge:
     138           0 :                         return "HUGEINT";
     139             : #endif
     140           0 :                 default:
     141           0 :                         return "UNKNOWN";
     142             :         }
     143             : }
     144             : 
     145         153 : int PyType_ToBat(int type)
     146             : {
     147         153 :         switch (type) {
     148             :                 case NPY_BOOL:
     149             :                         return TYPE_bit;
     150             :                 case NPY_BYTE:
     151             :                         return TYPE_bte;
     152             :                 case NPY_SHORT:
     153             :                         return TYPE_sht;
     154             :                 case NPY_INT:
     155             :                         return TYPE_int;
     156             :                 case NPY_LONG:
     157             : #if SIZEOF_LONG == 4
     158             :                         return TYPE_int;
     159             : #endif
     160             :                 case NPY_LONGLONG:
     161             :                         return TYPE_lng;
     162             :                 case NPY_UINT32:
     163             :                 case NPY_UINT64:
     164             :                         return TYPE_oid;
     165             :                 case NPY_FLOAT16:
     166             :                 case NPY_FLOAT:
     167             :                         return TYPE_flt;
     168             :                 case NPY_DOUBLE:
     169             :                 case NPY_LONGDOUBLE:
     170             :                         return TYPE_dbl;
     171             :                 case NPY_STRING:
     172             :                         return TYPE_str;
     173             :                 case NPY_UNICODE:
     174             :                         return TYPE_str;
     175             :                 default:
     176             :                         return TYPE_void;
     177             :         }
     178             : }
     179             : 
     180           0 : int BatType_ToPyType(int type)
     181             : {
     182           0 :         if (type == TYPE_blob) {
     183             :                 return NPY_OBJECT;
     184             :         }
     185           0 :         switch (type) {
     186             :                 case TYPE_void:
     187             : #if SIZEOF_OID == SIZEOF_INT
     188             :                         return NPY_UINT;
     189             : #else
     190             :                         return NPY_ULONGLONG;
     191             : #endif
     192             :                 case TYPE_bit:
     193             :                         return NPY_BOOL;
     194             :                 case TYPE_bte:
     195             :                         return NPY_INT8;
     196             :                 case TYPE_sht:
     197             :                         return NPY_INT16;
     198             :                 case TYPE_int:
     199             :                         return NPY_INT32;
     200             :                 case TYPE_lng:
     201             :                         return NPY_INT64;
     202             :                 case TYPE_flt:
     203             :                         return NPY_FLOAT32;
     204             :                 case TYPE_dbl:
     205             :                         return NPY_FLOAT64;
     206             :                 case TYPE_str:
     207             :                         return NPY_UNICODE;
     208             :                 case TYPE_oid:
     209             : #if SIZEOF_OID == SIZEOF_INT
     210             :                         return NPY_UINT32;
     211             : #else
     212             :                         return NPY_UINT64;
     213             : #endif
     214             : #ifdef HAVE_HGE
     215             :                 case TYPE_hge:
     216             :                         return NPY_FLOAT64;
     217             : #endif
     218             :                 default:
     219             :                         return NPY_STRING;
     220             :         }
     221             : }
     222             : 
     223         173 : bool PyType_IsPandasDataFrame(PyObject *object)
     224             : {
     225         173 :         PyObject *str = PyObject_Str(PyObject_Type(object));
     226         173 :         bool ret = strcmp(PyString_AsString(str),
     227             :                                           "<class 'pandas.core.frame.DataFrame'>") == 0;
     228         173 :         Py_DECREF(str);
     229         173 :         return ret;
     230             : }
     231             : 
     232         117 : bool PyType_IsNumpyMaskedArray(PyObject *object)
     233             : {
     234         117 :         PyObject *str = PyObject_Str(PyObject_Type(object));
     235         117 :         bool ret = strcmp(PyString_AsString(str),
     236             :                                           "<class 'numpy.ma.core.MaskedArray'>") == 0;
     237         117 :         Py_DECREF(str);
     238         117 :         return ret;
     239             : }
     240             : 
     241           0 : bool PyType_IsLazyArray(PyObject *object)
     242             : {
     243           0 :         PyObject *str = PyObject_Str(PyObject_Type(object));
     244           0 :         bool ret = strcmp(PyString_AsString(str), "<class 'lazyarray'>") == 0;
     245           0 :         Py_DECREF(str);
     246           0 :         return ret;
     247             : }
     248             : 
     249         117 : bool PyType_IsNumpyArray(PyObject *object)
     250             : {
     251         117 :         return PyArray_CheckExact(object);
     252             : }
     253             : 
     254         308 : bool Python_ObtainGIL(void)
     255             : {
     256         308 :         PyGILState_STATE gstate = PyGILState_Ensure();
     257         308 :         return gstate == PyGILState_LOCKED ? 0 : 1;
     258             : }
     259             : 
     260         308 : bool Python_ReleaseGIL(bool state)
     261             : {
     262         616 :         PyGILState_STATE gstate =
     263         308 :                 state == 0 ? PyGILState_LOCKED : PyGILState_UNLOCKED;
     264         308 :         PyGILState_Release(gstate);
     265         308 :         return 0;
     266             : }
     267             : 
     268             : // Returns true if the type of [object] is a scalar (i.e. numeric scalar or
     269             : // string, basically "not an array but a single value")
     270         696 : bool PyType_IsPyScalar(PyObject *object)
     271             : {
     272         696 :         if (object == NULL)
     273             :                 return false;
     274         696 :         return (PyArray_CheckScalar(object) || PyInt_Check(object) ||
     275         251 :                         PyFloat_Check(object) || PyLong_Check(object) ||
     276         229 :                         PyString_Check(object) || PyBool_Check(object) ||
     277         229 :                         PyUnicode_Check(object) || PyByteArray_Check(object)
     278             : #ifdef IS_PY3K
     279        1394 :                         || PyBytes_Check(object)
     280             : #endif
     281             :                                 );
     282             : }
     283             : 
     284           7 : void _pytypes_init(void) { _import_array(); }

Generated by: LCOV version 1.14