1#   coding=utf-8
   2#  #
   3#   Author: Ernesto Arredondo Martinez (ernestone@gmail.com)
   4#   File: gestor_oracle.py
   5#   Created: 05/04/2020, 00:38
   6#   Last modified: 10/11/2019, 11:24
   7#   Copyright (c) 2020
   8
   9import csv
  10import datetime
  11import inspect
  12import itertools
  13import json
  14import os
  15import shutil
  16import sys
  17from collections import namedtuple, OrderedDict
  18from functools import wraps
  19from logging import Logger
  20from subprocess import Popen, PIPE
  21from tempfile import SpooledTemporaryFile
  22from zipfile import ZipFile, ZIP_DEFLATED
  23
  24import lxml.etree as etree
  25import oracledb as cx_Oracle
  26
  27from apb_extra_utils import utils_logging
  28from apb_extra_utils.sql_parser import x_sql_parser
  29from apb_extra_utils.utils_logging import logger_path_logs
  30from apb_spatial_utils import topojson_utils
  31from . import sdo_geom as m_sdo_geom
  32
  33# Nombres tipo geometria GTYPE oracle por orden valor GTYPE
  34GTYPES_ORA = ["DEFAULT",
  35              "POINT",
  36              "LINE",
  37              "POLYGON",
  38              "COLLECTION",
  39              "MULTIPOINT",
  40              "MULTILINE",
  41              "MULTIPOLYGON"]
  42
  43# Se inicializan tipos de geometria Oracle
  44__class_tips_geom_ora = {}
  45for nom_tip in GTYPES_ORA:
  46    __class_tips_geom_ora[nom_tip] = namedtuple("gtype_" + nom_tip.upper(),
  47                                                ['TABLE_NAME', 'COLUMN_NAME', 'GTYPE', 'SRID'])
  48
  49
  50def class_tip_geom(gtype_ora="DEFAULT"):
  51    """
  52    Retorna NAMEDTUPLE 'cursor_desc_tip_geom_GTYPE' con columnas
  53    'TABLE_NAME', 'COLUMN_NAME', 'GTYPE', 'SRID'
  54
  55    Args:
  56        gtype_ora: tipo geometrias como claves en __class_tips_geom_ora
  57
  58    Returns:
  59        namedtuple('TABLE_NAME', 'COLUMN_NAME', 'GTYPE', 'SRID')
  60
  61    """
  62    gtype_ora = gtype_ora.upper()
  63
  64    if gtype_ora not in __class_tips_geom_ora:
  65        gtype_ora = "DEFAULT"
  66
  67    return __class_tips_geom_ora.get(gtype_ora)
  68
  69
  70# Caches para atributos de tablas_o_vistas de Oracle
  71__cache_pks_tab = {}
  72__cache_row_desc_tab = {}
  73__cache_tips_geom_tab = {}
  74__cache_row_class_tab = {}
  75
  76
  77def del_cache_rel_con_db(con_db_name: str):
  78    """
  79    Borra las Caches para atributos de tablas_o_vistas de Oracle
  80    Args:
  81        con_db_name: nom de la connexió
  82
  83    Returns:
  84
  85    """
  86    all_cache = [__cache_pks_tab, __cache_row_desc_tab, __cache_tips_geom_tab, __cache_row_class_tab]
  87    for cache_dic in all_cache:
  88        # alamcenamos las claves porque no se puede eliminar del diccionario mientras se itera
  89        keys_remove = []
  90        for key in cache_dic:
  91            if key.startswith(con_db_name):
  92                keys_remove.append(key)
  93        for key_r in keys_remove:
  94            del cache_dic[key_r]
  95
  96
  97def get_oracle_connection(user_ora, psw_ora, dsn_ora=None, call_timeout=None, schema_ora=None):
  98    """
  99    Return cx_Oracle Connection
 100    Args:
 101        user_ora (str):
 102        psw_ora (str):
 103        dsn_ora (str=None):
 104        call_timeout (int=None): miliseconds
 105        schema_ora(str=None): indicate scheme when it is different from the user, default schema = user
 106
 107    Returns:
 108        cx_Oracle.Connection
 109    """
 110    connection = cx_Oracle.connect(dsn=dsn_ora, user=user_ora, password=psw_ora)
 111    if call_timeout:
 112        connection.call_timeout = call_timeout
 113
 114    if schema_ora:
 115        connection.current_schema = schema_ora
 116
 117    return connection
 118
 119
 120def get_nom_conexion(con_db):
 121    """
 122    Devuelve el nombre de la conexion a Oracle
 123
 124    Args:
 125        con_db:
 126
 127    Returns:
 128
 129    """
 130    return "@".join((con_db.username.upper(), con_db.dsn.upper()))
 131
 132
 133def new_cursor(con_db, input_handler=None, output_handler=None):
 134    """
 135    Retorna cx_Oracle.Cursor con los handlers pasados por parámetro
 136
 137    Args:
 138        con_db:
 139        input_handler:
 140        output_handler:
 141
 142    Returns:
 143        cx_Oracle.cursor
 144    """
 145    try:
 146        curs = con_db.cursor()
 147
 148        if input_handler:
 149            curs.inputtypehandler = input_handler
 150
 151        if output_handler:
 152            curs.outputtypehandler = output_handler
 153
 154        return curs
 155
 156    except cx_Oracle.Error as exc:
 157        print("!!ERROR!! - Error al instanciar Cursor para la conexion Oracle {}\n"
 158              "     Error: {}".format(get_nom_conexion(con_db), exc))
 159        raise
 160
 161
 162def get_row_descriptor(curs, nom_base_desc=None):
 163    """
 164    Retorna instancia namedtuple indexada por las columnas de la query ejecutada en el cursor con los
 165    tipos de columna por valores.
 166
 167    Si se pasa nom_base_desc se hará heredar el namedtuple de esa clase
 168
 169    Args:
 170        curs:
 171        nom_base_desc:
 172
 173    Returns:
 174
 175    """
 176    ora_desc = None
 177    dd_reg = curs.description
 178    dict_camps = OrderedDict.fromkeys([def_col[0].replace(" ", "_") for def_col in dd_reg])
 179    if nom_base_desc:
 180        # Por si viene nombre de tabla con esquema delante nos quedamos solo con la ultima parte
 181        nom_base_desc = nom_base_desc.split(".")[-1]
 182        nom_base_desc += "_cursor"
 183    else:
 184        nom_base_desc = "cursor_" + str(id(curs))
 185
 186    try:
 187        nt_class = namedtuple(nom_base_desc,
 188                              list(dict_camps))
 189        ora_desc = nt_class(*[def_cols[1] for def_cols in dd_reg])
 190    except ValueError:
 191        raise Exception("!ERROR! - No se puede crear descriptor de fila para el SQL especificado. "
 192                        "El nombre de la columna {} no es válido".format(str(sys.exc_info()[1]).split(":")[1]),
 193                        sys.exc_info())
 194
 195    return ora_desc
 196
 197
 198def get_row_class_cursor(cursor_desc, con_db):
 199    """
 200    Retorna clase de fila por defecto (class row_cursor) para un cursor
 201
 202    Args:
 203        cursor_desc: (opcional) clase de la que se quiera heredar
 204        con_db: conexión cx_Oracle
 205
 206    Returns:
 207        class (default = row_cursor)
 208    """
 209    cls_curs_dsc = type(cursor_desc)
 210
 211    class row_cursor(cls_curs_dsc):
 212        """
 213        Clase para fila devuelta por query SQL (para queries que NO sean sobre una tabla/vista)
 214        """
 215        ora_descriptor = cursor_desc
 216        con_ora = con_db
 217
 218        def vals(self):
 219            """
 220            Valores de la fila
 221
 222            Returns:
 223                OrderedDict
 224            """
 225            return self._asdict()
 226
 227        def as_xml(self,
 228                   nom_root_xml="root_reg_sql",
 229                   atts_root_xml=None,
 230                   excluded_cols=None,
 231                   as_etree_elem=False):
 232            """
 233            Devuelve fila en formato XML
 234
 235            Args:
 236                nom_root_xml: define el nombre del TAG root del XML. Por defecto 'root_reg_sql'
 237                atts_root_xml: lista que define las columnas que se asignarán
 238                               como atributos del TAG root
 239                excluded_cols: lista con nombres de columnas que no se quieran incluir
 240                as_etree_elem (default=False): Si True devuelve registro como objeto etree.Element.
 241                                              Si False (por defecto) como str en formato XML
 242
 243            Returns:
 244                str (formato XML) OR etree.Element
 245            """
 246            if not excluded_cols:
 247                excluded_cols = list()
 248
 249            atts_xml = None
 250            d_xml_elems = self.xml_elems()
 251            if atts_root_xml:
 252                atts_xml = OrderedDict({att.lower(): d_xml_elems[att.lower()]
 253                                        for att in atts_root_xml})
 254
 255            tab_elem = etree.Element(nom_root_xml.lower(), atts_xml)
 256            excluded_cols = [c.lower() for c in excluded_cols]
 257            for tag, xml_val in d_xml_elems.items():
 258                if tag in excluded_cols:
 259                    continue
 260
 261                try:
 262                    camp_elem = etree.SubElement(tab_elem, tag.lower())
 263                    camp_elem.text = xml_val
 264                except:
 265                    print("!ERROR! - No se ha podido añadir el campo '",
 266                          tag, "' al XML", sep="")
 267
 268            ret = tab_elem
 269
 270            if not as_etree_elem:
 271                ret = etree.tostring(tab_elem, encoding="unicode")
 272
 273            return ret
 274
 275        def xml_elems(self):
 276            """
 277            Itera los campos del registro y devuelve su nombre y su valor parseado para XML
 278
 279            Yields:
 280                n_camp, val_camp
 281            """
 282            d_xml_elems = dict()
 283            for camp, val in self.vals().items():
 284                ret_val = ""
 285                if isinstance(val, datetime.datetime):
 286                    ret_val = val.strftime("%Y-%m-%dT%H:%M:%S")
 287                elif isinstance(val, m_sdo_geom.sdo_geom):
 288                    ret_val = val.as_wkt()
 289                elif val:
 290                    ret_val = str(val)
 291
 292                d_xml_elems[camp.lower()] = ret_val
 293
 294            return d_xml_elems
 295
 296        def as_json(self):
 297            """
 298            Retorna la fila como JSON con las geometrias en formato GeoJson
 299
 300            Returns:
 301                str con la fila en formato json
 302            """
 303            return json.dumps(self.vals(),
 304                              ensure_ascii=False,
 305                              cls=geojson_encoder)
 306
 307        def as_geojson(self):
 308            """
 309            Retorna la fila como GEOJSON
 310
 311            Returns:
 312                str con la fila en formato geojson
 313            """
 314            return json.dumps(self.__geo_interface__,
 315                              ensure_ascii=False,
 316                              cls=geojson_encoder)
 317
 318        @property
 319        def __geo_interface__(self):
 320            """
 321            GeoJSON-like protocol for geo-spatial para toda una fila devuelta por query SQL
 322
 323            Si la fila tiene varias geometrias devolverá geojson como "GeometryCollection"
 324
 325            Returns:
 326                dict con las geometrias y campos alfanuméricos (properties de Feature) en formato geojson
 327            """
 328            geos = dict(**self.sdo_geoms)
 329            num_geos = len(geos)
 330            geom = None
 331            if num_geos == 1:
 332                geom = next(iter(geos.values()))
 333            elif num_geos > 1:
 334                geom = {"type": "GeometryCollection",
 335                        "geometries": list(geos.values())}
 336
 337            if geom:
 338                return dict({"type": "Feature",
 339                             "geometry": geom,
 340                             "properties": {nc: val for nc, val in self.vals().items() if nc not in geos}})
 341
 342        @property
 343        def sdo_geoms(self):
 344            """
 345            Devuelve diccionario indexado por los nombres de columnas que tienen valor geometrico de la clase sdo_geom
 346
 347            Returns:
 348                dict {nom_column:sdo_geom}
 349            """
 350            return {nc: g.__geo_interface__
 351                    for nc, g in self.vals().items() if isinstance(g, m_sdo_geom.sdo_geom)}
 352
 353        def geometries(self, as_format=None):
 354            """
 355            Itera por los campos geométricos informados
 356
 357            Args:
 358                as_format (default=None): Se puede informar con nombre funcion 'as_XXXX' a la que responda SDO_GEOM
 359
 360            Yields:
 361                nom_camp, geom
 362            """
 363            for ng, g in self.vals().items():
 364                if isinstance(g, m_sdo_geom.sdo_geom):
 365                    g_val = g
 366                    if as_format:
 367                        g_val = getattr(g, as_format)()
 368
 369                    yield ng, g_val
 370
 371        @property
 372        def cols_pts_angles(self):
 373            """
 374            Devuelve diccionario de campos angulo para geometrias puntuales con la clave el nombre del campo angulo y
 375            el valor el nombre del campo puntual al que hace referencia
 376
 377            Returns:
 378                dict
 379            """
 380            sufix_ang = "_ANG"
 381            cols = self.cols
 382            cols_ang = {}
 383            for c in (c for c, gd in self.geoms_vals().items() if gd.GTYPE.endswith('POINT')):
 384                col_ang = x_sql_parser.get_nom_obj_sql(c, sufix=sufix_ang)
 385                if col_ang in cols:
 386                    cols_ang[col_ang] = c
 387
 388            return cols_ang
 389
 390        @property
 391        def cols(self):
 392            """
 393            Devuelve lista con el nombre de la columnas de la fila
 394
 395            Returns:
 396                list con nombres columnas
 397            """
 398            return self._fields
 399
 400    return row_cursor
 401
 402
 403def get_pk_tab(con_db, nom_tab_or_view):
 404    """
 405    Retorna la PRIMARY KEY de una tabla o vista de Oracle
 406
 407    Args:
 408        con_db:
 409        nom_tab_or_view:
 410
 411    Returns:
 412        lista nombre columnas clave
 413    """
 414    nom_pk_cache = get_nom_conexion(con_db) + ":" + nom_tab_or_view.upper()
 415    noms_camps_pk = __cache_pks_tab.get(nom_pk_cache)
 416    if not noms_camps_pk:
 417        sql_keys = "SELECT cols.column_name " \
 418                   "FROM user_constraints cons, user_cons_columns cols " \
 419                   "WHERE cols.table_name = :1 " \
 420                   "AND cons.constraint_type = 'P' " \
 421                   "AND cons.constraint_name = cols.constraint_name " \
 422                   "AND cons.owner = cols.owner " \
 423                   "ORDER BY cols.table_name, cols.position"
 424
 425        noms_camps_pk = [fila_val.COLUMN_NAME for fila_val in
 426                         iter_execute_fetch_sql(con_db, sql_keys, nom_tab_or_view.upper())]
 427        __cache_pks_tab[nom_pk_cache] = noms_camps_pk
 428
 429    return noms_camps_pk
 430
 431
 432def get_tips_geom_tab(con_db, nom_tab_or_view):
 433    """
 434    Retorna diccionario con nombre del campo como indice y los tipos de campos geométricos
 435    (class_tip_geom) registrados en la global __class_tips_geom_ora como clases 'c_desc_tip_geom_?' siendo ?
 436    el LAYER_GTYPE del indice de Oracle
 437
 438    Args:
 439        con_db:
 440        nom_tab_or_view:
 441
 442    Returns:
 443        dict indexado por nombre columnas geometria y la clase de geometria (__class_tips_geom_ora)
 444    """
 445    nom_con = get_nom_conexion(con_db)
 446
 447    tips_geom_con = __cache_tips_geom_tab.get(nom_con)
 448    if not tips_geom_con:
 449        tips_geom_con = __cache_tips_geom_tab[nom_con] = {}
 450        sql_tip_geom = "select  /*+ result_cache */ " \
 451                       "        T_COLS.TABLE_NAME, " \
 452                       "        T_COLS.COLUMN_NAME, " \
 453                       "        V_IDX_META.SDO_LAYER_GTYPE GTYPE, " \
 454                       "        V_G_META.SRID " \
 455                       "from    user_tab_columns t_cols," \
 456                       "        user_sdo_geom_metadata v_g_meta," \
 457                       "        user_sdo_index_info v_idx_info," \
 458                       "        user_sdo_index_metadata v_idx_meta " \
 459                       "where v_g_meta.table_name = t_cols.table_name and " \
 460                       "v_g_meta.column_name = t_cols.column_name and" \
 461                       "    v_idx_info.table_name = t_cols.table_name and " \
 462                       "v_idx_info.column_name = t_cols.column_name and" \
 463                       "    v_idx_meta.sdo_index_name = v_idx_info.index_name"
 464
 465        for reg_tip_geom in iter_execute_fetch_sql(con_db, sql_tip_geom):
 466            nom_cache = reg_tip_geom.TABLE_NAME.upper()
 467            cache_tips_geom = tips_geom_con.get(nom_cache)
 468            if not cache_tips_geom:
 469                cache_tips_geom = {}
 470                tips_geom_con[nom_cache] = cache_tips_geom
 471
 472            tip_geom = class_tip_geom(reg_tip_geom.GTYPE)(*reg_tip_geom.vals().values())
 473
 474            nom_camp_geom = reg_tip_geom.COLUMN_NAME.upper()
 475            cache_tips_geom[nom_camp_geom] = tip_geom
 476
 477    tips_geom = tips_geom_con.get(nom_tab_or_view.upper())
 478
 479    return tips_geom if tips_geom else {}
 480
 481
 482def get_row_desc_tab(con_db, nom_tab_or_view):
 483    """
 484    Retorna el descriptor (cursor con los tipos de campo para cada columna) de una tabla o vista de Oracle
 485
 486    Args:
 487        con_db:
 488        nom_tab_or_view:
 489
 490    Returns:
 491        namedtuple ó clase fila con las columnas y sus tipos
 492    """
 493    nom_dd_cache = get_nom_conexion(con_db) + ":" + nom_tab_or_view.upper()
 494    tab_desc = __cache_row_desc_tab.get(nom_dd_cache)
 495    if not tab_desc:
 496        row_class_tab = get_row_class_tab(con_db, nom_tab_or_view)
 497
 498        camps_dd = row_class_tab.ora_descriptor
 499        dict_camps = camps_dd._asdict()
 500        dict_camps_geom = row_class_tab.geoms()
 501        if dict_camps_geom:
 502            for nom_camp, tip_camp_geom in dict_camps_geom.items():
 503                dict_camps[nom_camp] = tip_camp_geom
 504
 505        tab_desc = row_class_tab(*dict_camps.values())
 506        __cache_row_desc_tab[nom_dd_cache] = tab_desc
 507
 508    return tab_desc
 509
 510
 511def get_tip_camp(con_db, nom_tab_or_view, nom_camp):
 512    """
 513    Devuelve el tipo de campo para la tabla_vista y campo especificado. En el caso de campos alfanuméricos
 514    devuelve los tipos de cx_Oracle relacionados (cx_Oracle.NUMBER, cx_Oracle.STRING, ...) y para las
 515    geométricas del tipo CLASS_TIP_GEOM
 516
 517    Args:
 518        con_db:
 519        nom_tab_or_view:
 520        nom_camp:
 521
 522    Returns:
 523        object: (cx_Oracle.NUMBER, cx_Oracle.STRING, ...) o si geometria tipo en __class_tips_geom_ora
 524    """
 525    nom_tab_or_view = nom_tab_or_view.upper()
 526    nom_camp = nom_camp.upper()
 527
 528    dd_tab = get_row_desc_tab(con_db, nom_tab_or_view)
 529    if dd_tab:
 530        return getattr(dd_tab, nom_camp, None)
 531
 532
 533def sql_tab(nom_tab_or_view, filter_sql=None, columns=None):
 534    """
 535    Devuelve sql para tabla o vista
 536
 537    Args:
 538        nom_tab_or_view:
 539        filter_sql:
 540        columns (list): Lista nombre de columnas a mostrar. Default '*' (todas)
 541
 542    Returns:
 543        str: con select sql para tabla o vista
 544    """
 545    cols = "*"
 546    if columns:
 547        cols = ",".join(columns)
 548
 549    sql_tab = "select {cols} from {taula} TAB".format(
 550        taula=nom_tab_or_view,
 551        cols=cols)
 552
 553    if filter_sql:
 554        sql_tab += " where " + filter_sql
 555
 556    return sql_tab
 557
 558
 559def get_row_class_tab(con_db, nom_tab_or_view):
 560    """
 561    Retorna clase que hereda de namedtuple para instanciar con los valores de un nuevo registro
 562
 563    Args:
 564        con_db:
 565        nom_tab_or_view:
 566
 567    Returns:
 568        object: clase que hereda del namedtuple para una fila
 569    """
 570    nom_tab_or_view = nom_tab_or_view.upper()
 571    nom_row_class_tab_cache = get_nom_conexion(con_db) + ":" + nom_tab_or_view
 572    row_class_tab = __cache_row_class_tab.get(nom_row_class_tab_cache)
 573
 574    if not row_class_tab:
 575        curs = con_db.cursor()
 576        curs.execute(sql_tab(nom_tab_or_view))
 577        ora_desc = get_row_descriptor(curs, nom_tab_or_view)
 578
 579        row_cursor_cls = get_row_class_cursor(ora_desc, con_db)
 580
 581        class row_table(row_cursor_cls):
 582            """
 583            Clase para fila devuelta por SQL sobre tabla
 584            """
 585            nom_tab = nom_tab_or_view
 586
 587            def __repr__(self):
 588                """
 589                built_in que actua cuando se representa clase como STRING
 590
 591                Returns:
 592                    str
 593                """
 594                repr_txt = nom_tab_or_view + "({pk_vals})"
 595                pk_txt = []
 596                for i, v in self.pk_vals().items():
 597                    pk_txt.append(str(i) + "=" + str(v))
 598
 599                return repr_txt.format(pk_vals=",".join(pk_txt))
 600
 601            @staticmethod
 602            def pk():
 603                """
 604                Retorna lista con los nombres de campos clave
 605
 606                Returns:
 607                    list con nombres campos clave
 608                """
 609                return get_pk_tab(con_db, nom_tab_or_view)
 610
 611            def pk_vals(self):
 612                """
 613                Retorna OrderedDict con los pares nombres:valor para los campos clave
 614
 615                Returns:
 616                    OrderedDict
 617                """
 618                pk_vals = OrderedDict.fromkeys(self.pk())
 619                for k in self.pk():
 620                    pk_vals[k] = self.vals().get(k)
 621
 622                return pk_vals
 623
 624            @staticmethod
 625            def geoms():
 626                """
 627                Devuelve diccionario {nom_camp_geom:tip_geom} para todas las columnas de la tabla que son de
 628                tipo geométrico.
 629                Lo deduce de la definición de la tabla independientemente de si la columna está informada o no
 630
 631                Returns:
 632                    dict {nom_geom:tip_geom} (vease funcion clas_tip_geom())
 633                """
 634                return get_tips_geom_tab(con_db, nom_tab_or_view)
 635
 636            def geoms_vals(self):
 637                """
 638                Valores de los campos geometricos
 639
 640                Returns:
 641                    dict
 642                """
 643                vals = self.vals()
 644                return {nc: vals[nc] for nc in self.geoms()}
 645
 646            def as_xml(self, excluded_cols=[],
 647                       as_etree_elem=False):
 648                """
 649                Devuelve row como XML
 650
 651                Args:
 652                    excluded_cols: lista de nombre de columnas que se quieren excluir
 653                    as_etree_elem {bool} (default=False): Si True devuelve registro como objeto etree.Element. Si False (por defecto) como str en formato XML
 654
 655                Returns:
 656                    str (formato XML) OR etree.Element
 657                """
 658                return super(row_table, self).as_xml(nom_tab_or_view,
 659                                                     self.pk_vals(),
 660                                                     excluded_cols,
 661                                                     as_etree_elem)
 662
 663            @staticmethod
 664            def get_row_desc():
 665                return get_row_desc_tab(con_db, nom_tab_or_view)
 666
 667            @staticmethod
 668            def alfas(include_pk=True):
 669                """
 670                Devuelve diccionario {nom_camp:tip_camp} para las columnas alfanuméricas (NO son geométricas)
 671                Lo deduce de la definición de la tabla independientemente de si la columna está informada o no
 672
 673                Args:
 674                    include_pk: incluir primary key
 675
 676                Returns:
 677                    dict {nom_camp:tip_camp}
 678                """
 679                return {nc: tc
 680                        for nc, tc in get_row_desc_tab(con_db, nom_tab_or_view).vals().items()
 681                        if nc not in get_tips_geom_tab(con_db, nom_tab_or_view) and
 682                        (include_pk or nc not in get_pk_tab(con_db, nom_tab_or_view))}
 683
 684            def alfas_vals(self):
 685                """
 686                Devuelve diccionario con valores campos alfanuméricos
 687
 688                Returns:
 689                    dict {nom_camp:val_camp}
 690                """
 691                vals = self.vals()
 692                return {nc: vals[nc] for nc in self.alfas()}
 693
 694        row_class_tab = row_table
 695        __cache_row_class_tab[nom_row_class_tab_cache] = row_class_tab
 696
 697    return row_class_tab
 698
 699
 700def get_row_factory(curs, a_row_class=None, func_format_geom: str = None):
 701    """
 702    Retorna funcion para crear instancia clase a partir de los valores de una fila
 703
 704    Args:
 705        curs (cx_Oracle.Cursor): cursor de la consulta
 706        a_row_class (object=None): clase que se utilizará para crear la fila. Si no se informa se crea una clase
 707        func_format_geom (str=None): nombre función para formatear las geometrías SDO_GEOMETRY.
 708                (veanse las funciones sdo_geom as_[format])
 709
 710    Returns:
 711        function row_factory_func
 712    """
 713    con_db = curs.connection
 714    if not a_row_class:
 715        cursor_desc = get_row_descriptor(curs)
 716        a_row_class = get_row_class_cursor(cursor_desc, con_db)
 717
 718    f_sd_geom = m_sdo_geom.get_build_sdo_geom(con_db, func_format_geom=func_format_geom)
 719
 720    def row_factory_func(*vals_camps):
 721        has_sdo_geom = any(
 722            isinstance(val, cx_Oracle.DbObject) and val.type.name == "SDO_GEOMETRY"
 723            for val in vals_camps
 724        )
 725        if has_sdo_geom:
 726            vals_camps = [
 727                f_sd_geom(val) if isinstance(val, cx_Oracle.DbObject) and
 728                                  val.type.name == "SDO_GEOMETRY" else val
 729                for val in vals_camps
 730            ]
 731
 732        return a_row_class(*vals_camps)
 733
 734    return row_factory_func
 735
 736
 737def get_row_cursor(curs, rowfactory=None):
 738    """
 739    Retorna fila como clase que construye el rowfactory. Por defecto si no se informa esta clase heredará
 740    de 'namedtuple' con los campos como items más funcionalidad relacionada con la conexion y el descriptor de la fila
 741    con los tipos de campo para cada columna
 742
 743    Args:
 744        curs:
 745        rowfactory:
 746
 747    Returns:
 748
 749    """
 750    set_cursor_row_factory(curs, rowfactory)
 751
 752    row = curs.fetchone()
 753
 754    return row
 755
 756
 757def set_cursor_row_factory(curs, rowfactory=None):
 758    """
 759    Asigna al cursor la funcion rowfactory para crear las filas devueltas por el cursor
 760
 761    Args:
 762        curs (cx_Oracle.Cursor):
 763        rowfactory (function=None):
 764
 765    Returns:
 766        None
 767    """
 768    if not rowfactory and not curs.rowfactory:
 769        rowfactory = get_row_factory(curs)
 770
 771    if rowfactory:
 772        curs.rowfactory = rowfactory
 773
 774
 775def iter_execute_fetch_sql(con_db, sql_str, *args_sql, logger: Logger = None, **extra_params):
 776    """
 777    Itera y devuelve cada fila devuelta para la consulta sql_str
 778
 779    Args:
 780        con_db (cx_Oracle.Connection): conexión a Oracle
 781        sql_str (str): consulta SQL
 782        *args_sql: argumentos para la consulta SQL
 783        logger (Logger=None): Logger para registrar errores
 784        **extra_params: {
 785            "row_class": clase que se utilizará para cada fila. Vease get_row_factory()
 786            "as_format": formato en el que se devuelve cada fila.
 787                Las clases base row_cursor y row_table.
 788                (vease get_row_class_cursor() y get_row_class_tab()) responden
 789                por defecto a"as_xml()" y "as_json()"
 790            "geom_format": nombre función para formatear las geometrías SDO_GEOMETRY. (vease sdo_geom as_[format])
 791            "rowfactory": función rowfactory para crear las filas devueltas por el cursor
 792            "input_handler": función input_handler para el cursor (vease sdo_geom.get_sdo_input_handler())
 793        }
 794
 795    Returns:
 796        row_class o string en formato especificado en **extra_params["as_format"]
 797    """
 798    curs = None
 799
 800    try:
 801        curs = new_cursor(con_db,
 802                          input_handler=extra_params.pop("input_handler",
 803                                                         m_sdo_geom.get_sdo_input_handler()),
 804                          )
 805
 806        if (rowfactory := extra_params.pop("rowfactory", None)) is None:
 807            row_class = extra_params.pop("row_class", None)
 808            curs_aux = new_cursor(con_db)
 809            curs_aux.execute(sql_str, args_sql)
 810            rowfactory = get_row_factory(
 811                curs_aux, row_class,
 812                func_format_geom=extra_params.pop("geom_format", None)
 813            )
 814
 815        curs.prefetchrows = extra_params.pop("prefetchrows", 0)
 816        curs.arraysize = extra_params.pop("arraysize", 5_000)
 817        curs.execute(sql_str, args_sql)
 818        curs.rowfactory = rowfactory
 819
 820        num_rows = 0
 821        for reg in curs:
 822            if logger:
 823                num_rows += 1
 824                logger.debug(f"Num row {num_rows}: {reg}")
 825
 826            if "as_format" in extra_params:
 827                f_format = extra_params["as_format"]
 828                if f_format:
 829                    reg = getattr(reg, f_format)()
 830
 831            yield reg
 832
 833    except:
 834        if curs is not None:
 835            curs.close()
 836        raise
 837
 838    if curs is not None:
 839        curs.close()
 840
 841
 842def execute_fetch_sql(con_db, sql_str, *args_sql, **extra_params):
 843    """
 844    Devuelve la primera iteración sobre la consulta sql_str
 845
 846    Args:
 847        con_db (cx_Oracle.Connection): conexión a Oracle
 848        sql_str (str): consulta SQL
 849        *args_sql: argumentos para la consulta SQL
 850        **extra_params: {
 851            "row_class": clase que se utilizará para cada fila. Vease get_row_factory()
 852            "as_format": formato en el que se devuelve cada fila.
 853                Las clases base row_cursor y row_table.
 854                (vease get_row_class_cursor() y get_row_class_tab()) responden
 855                por defecto a"as_xml()" y "as_json()"
 856            "geom_format": nombre función para formatear las geometrías SDO_GEOMETRY. (vease sdo_geom as_[format])
 857            "rowfactory": función rowfactory para crear las filas devueltas por el cursor
 858            "input_handler": función input_handler para el cursor (vease sdo_geom.get_sdo_input_handler())
 859        }
 860
 861    Returns:
 862        row_class o string en formato especificado en **extra_params["as_format"]
 863    """
 864    reg = None
 865    for row in iter_execute_fetch_sql(con_db, sql_str, *args_sql, **extra_params):
 866        reg = row
 867        break
 868
 869    return reg
 870
 871
 872def dict_as_sql_bind_and_params(dict_vals, bool_rel="and", filter_oper="="):
 873    """
 874    A partir de un dict de {nom_camps:value_camps} devuelve un string en forma
 875    de SQL FILTER bindind (camp_a = :1 and camp_b = :2) y la lista de params que se asignarán via binding
 876    El BOOL_REL podrá ser 'AND', 'OR' o ',' para el SET de los updates
 877    El FILTER_OPER podrá ser '=', '!=' o ':=' para el SET de los updates
 878
 879    Args:
 880        dict_vals:
 881        bool_rel:
 882        filter_oper:
 883
 884    Returns:
 885        str, [params*]
 886    """
 887    query_elems = {}
 888    for nom_camp, val_clau in dict_vals.items():
 889        sql_str = str(nom_camp) + " " + filter_oper + " :" + str(nom_camp)
 890        query_elems[sql_str] = val_clau
 891
 892    sql = (" " + bool_rel.strip().upper() + " ").join(query_elems.keys())
 893
 894    return sql, list(query_elems.values())
 895
 896
 897class SerializableGenerator(list):
 898    """Generator that is serializable by JSON
 899
 900    It is useful for serializing huge data by JSON
 901    It can be used in a generator of json chunks used e.g. for a stream
 902    ('[1', ']')
 903    # >>> for chunk in iter_json:
 904    # ...     stream.write(chunk)
 905    # >>> SerializableGenerator((x for x in range(3)))
 906    # [<generator object <genexpr> at 0x7f858b5180f8>]
 907    """
 908
 909    def __init__(self, iterable):
 910        super().__init__()
 911        tmp_body = iter(iterable)
 912        try:
 913            self._head = iter([next(tmp_body)])
 914            self.append(tmp_body)
 915        except StopIteration:
 916            self._head = []
 917
 918    def __iter__(self):
 919        return itertools.chain(self._head, *self[:1])
 920
 921
 922def geojson_from_gen_ora_sql(generator_sql, as_string=False):
 923    """
 924    Devuelve diccionario geojson para un generator de rows de Oracle
 925
 926    Args:
 927        generator_sql (function generator):
 928        as_string (bool): (opcional) indica si se querrá el geojson como un string
 929
 930    Returns:
 931        geojson (dict ó str)
 932    """
 933    vals = {"type": "FeatureCollection",
 934            "features": [getattr(r, "__geo_interface__")
 935                         for r in generator_sql
 936                         if getattr(r, "__geo_interface__")]}
 937
 938    ret = vals
 939    if as_string:
 940        ret = json.dumps(vals,
 941                         ensure_ascii=False)
 942
 943    return ret
 944
 945
 946def vector_file_from_gen_ora_sql(file_path, vector_format, func_gen, zipped=False, indent_json=None, cols_csv=None,
 947                                 tip_cols_csv=None):
 948    """
 949    A partir del resultado de una query SQL devuelve un file_object formateado segun formato
 950
 951    Args:
 952        file_path (str): path del fichero a grabar
 953        vector_format (str): tipo formato (CSV, JSON, GEOJSON)
 954        func_gen (generator function): funcion que devuelva filas sql en forma de row_cursor o row_table
 955                                      (vease funciones generator_rows_sql() o generator_rows_table())
 956        zipped (bool=False): Devuelve fichero en un fichero comprimido (.zip)
 957        indent_json (int):
 958        cols_csv (list): Lista de columnes del CSV
 959        tip_cols_csv (list): Lista de tipos de columnas para CSV.
 960                             Revisar especificacion en https://giswiki.hsr.ch/GeoCSV
 961    Returns:
 962        str: pathfile del fichero generado
 963    """
 964    vector_format = vector_format.lower()
 965    newline = None if vector_format != "csv" else ""
 966    file_path_csvt = None
 967    str_csvt = None
 968    dir_base = os.path.dirname(file_path)
 969    if dir_base:
 970        os.makedirs(dir_base, exist_ok=True)
 971
 972    # Se hace en memoria o recursos locales (SpooledTemporaryFile) para evitar trabajar lo minimo en la red
 973    # si se da el caso en el path fichero del fichero indicado. Cuando se quiere grabar en recurso local el tiempo
 974    # perdido por utilizar un fichero temporal debería ser despreciable comparado con la complejidad añadida al código
 975    # para decidir si usar o no el SpooledTemporaryFile
 976    with SpooledTemporaryFile(mode="w+", encoding="utf-8", newline=newline) as temp_file:
 977        if vector_format == "geojson":
 978            json.dump(geojson_from_gen_ora_sql(func_gen),
 979                      temp_file,
 980                      ensure_ascii=False,
 981                      indent=indent_json,
 982                      cls=geojson_encoder)
 983        elif vector_format == "json":
 984            json.dump(SerializableGenerator((r.vals() for r in func_gen)),
 985                      temp_file,
 986                      ensure_ascii=False,
 987                      indent=indent_json,
 988                      cls=geojson_encoder)
 989        elif vector_format == "csv":
 990            writer = csv.DictWriter(temp_file, fieldnames=cols_csv)
 991            writer.writeheader()
 992
 993            for r in func_gen:
 994                writer.writerow(r.vals())
 995
 996        temp_file.seek(0)
 997        if tip_cols_csv:
 998            file_path_csvt = ".".join((os.path.splitext(file_path)[0], "csvt"))
 999            str_csvt = ",".join(tip_cols_csv)
1000
1001        if zipped:
1002            file_path_res = "{}.zip".format(os.path.splitext(file_path)[0])
1003            with SpooledTemporaryFile() as zip_temp_file:
1004                with ZipFile(zip_temp_file, "w", compression=ZIP_DEFLATED, allowZip64=True) as my_temp_zip:
1005                    my_temp_zip.writestr(zinfo_or_arcname=os.path.basename(file_path), data=temp_file.read())
1006                    if str_csvt:
1007                        my_temp_zip.writestr(zinfo_or_arcname=os.path.basename(file_path_csvt), data=str_csvt)
1008
1009                zip_temp_file.seek(0)
1010                with open(file_path_res, mode="wb") as file_res:
1011                    shutil.copyfileobj(zip_temp_file, file_res)
1012        else:
1013            file_path_res = file_path
1014            with open(file_path_res, mode="w", encoding="utf-8") as file_res:
1015                shutil.copyfileobj(temp_file, file_res)
1016            if str_csvt:
1017                with open(file_path_csvt, mode="w") as csvt_file:
1018                    csvt_file.write(str_csvt)
1019
1020    return file_path_res
1021
1022
1023class geojson_encoder(json.JSONEncoder):
1024    """
1025    Class Encoder to parser SDO_GEOM to GEOJSON
1026    """
1027    __num_decs__ = 9
1028
1029    def default(self, obj_val):
1030        """
1031        Redefine default para tratar las geometrias SDO_GEOM y convertirlas a geojson y las fechas a iso_format
1032        Args:
1033            obj_val: valor
1034
1035        Returns:
1036            object encoded
1037        """
1038        if isinstance(obj_val, m_sdo_geom.sdo_geom):
1039            return obj_val.as_geojson()
1040        elif isinstance(obj_val, (datetime.datetime, datetime.date)):
1041            return obj_val.isoformat()
1042        elif isinstance(obj_val, cx_Oracle.LOB):
1043            return obj_val.read()
1044        else:
1045            return json.JSONEncoder.default(self, obj_val)
1046
1047
1048def print_to_log_exception(a_type_exc=Exception, lanzar_exc=False):
1049    """
1050    Decorator para imprimir en el log una excepción capturada por un metodo de la clase
1051
1052    Returns:
1053        function
1054    """
1055
1056    def decor_print_log_exception(func):
1057        @wraps(func)
1058        def meth_wrapper(cls, *args, **kwargs):
1059            try:
1060                return func(cls, *args, **kwargs)
1061            except a_type_exc:
1062                error_type, error_instance, traceback = sys.exc_info()
1063
1064                error_msg = "Error al executar funció '{clas}.{func}()' \n" \
1065                            "Arguments: {args}\n" \
1066                            "Fitxer:    {file}".format(
1067                    file=inspect.getmodule(func).__file__,
1068                    clas=cls.__class__.__name__,
1069                    func=func.__name__,
1070                    args=", ".join(["'{}'".format(arg) for arg in args] +
1071                                   ["'{}={}'".format(a, b) for a, b in kwargs.items()]))
1072
1073                if hasattr(error_instance, "output"):
1074                    error_msg += "\n" \
1075                                 "Output: {}".format(error_instance.output)
1076
1077                cls.print_log_exception(error_msg)
1078                if lanzar_exc:
1079                    raise error_instance
1080
1081        return meth_wrapper
1082
1083    return decor_print_log_exception
1084
1085
1086class gestor_oracle(object):
1087    """
1088    Clase que gestionará distintas conexiones a Oracle y facilitará operaciones sobre la BBDD
1089    """
1090    tip_number = cx_Oracle.NUMBER
1091    tip_string = cx_Oracle.STRING
1092    tip_clob = cx_Oracle.CLOB
1093    tip_blob = cx_Oracle.BLOB
1094    tip_date = cx_Oracle.DATETIME
1095    tip_fix_char = cx_Oracle.FIXED_CHAR
1096
1097    __slots__ = 'nom_con_db', '__con_db__', '__user_con_db__', \
1098        '__psw_con_db__', '__dsn_ora__', '__call_timeout__', '__schema_con_db__', 'logger'
1099
1100    def __init__(self, user_ora, psw_ora, dsn_ora, a_logger=None, call_timeout: int = None, schema_ora=None):
1101        """
1102        Inicializa gestor de Oracle para una conexion cx_Oracle a Oracle
1103        Se puede pasar por parametro un logger o inicializar por defecto
1104
1105        Args:
1106            user_ora {str}: Usuario/schema Oracle
1107            psw_ora {str}: Password usuario
1108            dsn_ora {str}: DSN Oracle (Nombre instancia/datasource de Oracle
1109                    según TSN o string tal cual devuelve cx_Oracle.makedsn())
1110            call_timeout (int=None): miliseconds espera per transaccio
1111            a_logger:
1112            schema_ora(str=None): indicate scheme when it is different from the user, default schema = user
1113        """
1114        self.__con_db__ = None
1115        self.__call_timeout__ = call_timeout
1116        self.logger = a_logger
1117        self.__set_logger()
1118        self.__set_conexion(user_ora, psw_ora, dsn_ora, schema_ora=schema_ora)
1119
1120    def __del__(self):
1121        """
1122        Cierra la conexion al matar la instancia
1123        """
1124        try:
1125            if hasattr(self, "__con_db__"):
1126                self.__con_db__.close()
1127        except:
1128            pass
1129
1130    def __repr__(self):
1131        """
1132        built_in que actua cuando se representa clase como STRING
1133
1134        Returns:
1135            str
1136        """
1137        repr_txt = "{}".format(self.nom_con_db)
1138
1139        return repr_txt
1140
1141    @staticmethod
1142    def log_dir():
1143        """
1144        Devuelve el directorio donde irán los logs indicado en la funcion apb_logging.logs_dir()
1145
1146        Returns:
1147            {str} - path del directorio de logs
1148        """
1149        return utils_logging.logs_dir(True)
1150
1151    def log_name(self):
1152        """
1153        Devuelve el nombre del fichero de log por defecto
1154
1155        Returns:
1156            {str} - Nombre fichero log por defecto
1157        """
1158        return self.__class__.__name__
1159
1160    def log_file_name(self):
1161        return "{}.(LOG_LEVEL).log".format(os.path.join(self.log_dir(), self.log_name()))
1162
1163    def __set_logger(self):
1164        """
1165        Asigna el LOGGER po defecto si este no se ha informado al inicializar el gestor
1166
1167        Returns:
1168        """
1169        if self.logger is None:
1170            self.logger = utils_logging.get_file_logger(self.log_name(), dir_log=self.log_dir())
1171
1172    def path_logs(self, if_exist=True):
1173        """
1174        Devuelve lista paths base de los logs vinculados al gestor
1175
1176        Args:
1177            if_exist (bool): Devuelve los paths si el fichero existe
1178
1179        Returns:
1180            list:
1181        """
1182        return logger_path_logs(self.logger)
1183
1184    def print_log(self, msg):
1185        """
1186        Sobre el logger escribe mensaje de info
1187
1188        Args:
1189            msg {str}: String con el mensaje
1190        """
1191        self.logger.info(msg)
1192
1193    def print_log_error(self, msg):
1194        """
1195        Sobre el logger escribe mensaje de error
1196
1197        Args:
1198            msg {str}: String con el mensaje
1199        """
1200        self.logger.error(msg)
1201
1202    def print_log_exception(self, msg):
1203        """
1204        Sobre el logger escribe excepcion
1205
1206        Args:
1207            msg {str}: String con el mensaje
1208        """
1209        self.logger.exception(msg)
1210
1211    @print_to_log_exception(lanzar_exc=True)
1212    def __set_conexion(self, user_ora, psw_ora, dsn_ora, schema_ora=None):
1213        """
1214        Añade conexion Oracle al gestor a partir de nombre de usuario/schema (user_ora), contraseña (psw_ora) y
1215        nombre datasource de la bbdd según tns_names (ds_ora).
1216
1217        La conexión quedará registrada como 'user_ora@ds_ora'
1218
1219        Args:
1220            user_ora {str}: Usuario/schema Oracle
1221            psw_ora {str}: Password usuario
1222            dsn_ora {str}: DSN Oracle (Nombre instancia/datasource de Oracle según TSN o string tal cual devuelve cx_Oracle.makedsn())
1223            schema_ora(str=None): indicate scheme when it is different from the user, default schema = user
1224
1225        """
1226        nom_con = "@".join((user_ora.upper(), dsn_ora.upper()))
1227        self.nom_con_db = nom_con
1228        self.__user_con_db__ = user_ora
1229        self.__psw_con_db__ = psw_ora
1230        self.__schema_con_db__ = schema_ora
1231        self.__dsn_ora__ = dsn_ora
1232        self.__con_db__ = get_oracle_connection(user_ora, psw_ora, dsn_ora, self.__call_timeout__,
1233                                                schema_ora=schema_ora)
1234
1235    @property
1236    @print_to_log_exception(cx_Oracle.Error, lanzar_exc=True)
1237    def con_db(self):
1238        """
1239        Return a cx_Oracle Conection live
1240        
1241        Returns:
1242            cx_Oracle.Connection
1243        """
1244        reconnect = False
1245        if (con_ora := self.__con_db__) is not None:
1246            try:
1247                con_ora.ping()
1248            except cx_Oracle.Error as exc:
1249                # Borramos las entradas de cache asociadas a la conexión que no responde
1250                del_cache_rel_con_db(get_nom_conexion(con_ora))
1251                try:
1252                    con_ora.close()
1253                except cx_Oracle.Error:
1254                    pass
1255                self.__con_db__ = con_ora = None
1256
1257        if con_ora is None:
1258            self.__set_conexion(
1259                self.__user_con_db__,
1260                self.__psw_con_db__,
1261                self.__dsn_ora__, schema_ora=self.__schema_con_db__)
1262
1263            con_ora = self.__con_db__
1264
1265        return con_ora
1266
1267    @print_to_log_exception(cx_Oracle.DatabaseError)
1268    def exec_trans_db(self, sql_str, *args_sql, **types_sql_args):
1269        """
1270        Ejecuta transaccion SQL
1271
1272        Args:
1273            sql_str (str): sql transaction (update, insert, delete}
1274            *args_sql: Lista argumentos a pasar
1275            **types_sql_args (OPCIONAL): Lista tipos cx_Oracle para cada argumento
1276
1277        Returns:
1278            ok {bool}: Si ha ido bien True si no False
1279        """
1280        curs_db = None
1281        try:
1282            curs_db = new_cursor(self.con_db,
1283                                 input_handler=m_sdo_geom.get_sdo_input_handler())
1284
1285            curs_db.setinputsizes(*types_sql_args.values())
1286
1287            curs_db.execute(sql_str,
1288                            args_sql)
1289        finally:
1290            if curs_db:
1291                curs_db.close()
1292
1293        return True
1294
1295    @print_to_log_exception(cx_Oracle.DatabaseError)
1296    def exec_script_plsql(self, sql_str):
1297        """
1298        Ejecuta script SQL
1299
1300        Args:
1301            sql_str {str}: sql script
1302
1303        Returns:
1304            ok {bool}: Si ha ido bien True si no False
1305        """
1306        curs_db = None
1307        try:
1308            curs_db = new_cursor(self.con_db)
1309            curs_db.execute(sql_str)
1310        finally:
1311            if curs_db:
1312                curs_db.close()
1313
1314        return True
1315
1316    @print_to_log_exception(cx_Oracle.DatabaseError)
1317    def callfunc_sql(self, nom_func, ret_cx_ora_tipo, *args_func):
1318        """
1319        Ejecuta funcion PL/SQL y retorna el valor
1320
1321        Args:
1322            nom_func (str): Nombre de la funcion PL/SQL
1323            ret_cx_ora_tipo (cx_Oracle TIPO): El retorno de la función en cx_Oracle (cx_Oracle.NUMBER,
1324                                            cx_Oracle.STRING,...)
1325            *args_func: Argumentos de la funcion PL/SQL
1326
1327        Returns:
1328            Valor retornado por la función PL/SQL
1329        """
1330        curs = None
1331        try:
1332            curs = new_cursor(self.con_db)
1333            ret = curs.callfunc(nom_func,
1334                                ret_cx_ora_tipo,
1335                                args_func)
1336        finally:
1337            if curs:
1338                curs.close()
1339
1340        return ret
1341
1342    @print_to_log_exception(cx_Oracle.DatabaseError)
1343    def callproc_sql(self, nom_proc, *args_proc):
1344        """
1345        Ejecuta procedimiento PL/SQL
1346
1347        Args:
1348            nom_proc (str): Nombre del procedimiento PL/SQL
1349            *args_proc: Argumentos del procedimiento
1350
1351        Returns:
1352            ok {bool}: Si ha ido bien True si no False
1353        """
1354        curs = None
1355        try:
1356            curs = new_cursor(self.con_db)
1357            curs.callproc(nom_proc,
1358                          args_proc)
1359        finally:
1360            if curs:
1361                curs.close()
1362
1363        return True
1364
1365    @print_to_log_exception(cx_Oracle.DatabaseError)
1366    def row_sql(self, sql_str, *args_sql, **extra_params):
1367        """
1368        Retorna la fila resultante de la query sql SQL_STR con los parámetros *ARGS_SQL.
1369        Se puede informar **EXTRA_PARAMS con algunos de los siguientes parámetros:
1370            INPUT_HANDLER funcion que tratará los bindings de manera específica
1371            OUTPUT_HANLER funcion que tratará los valores de las columnas de modo específico
1372            ROW_CLASS define que con que clase se devolverá cada fila. Por defecto la que devuleve la funcion
1373                      'apb_cx_oracle_spatial.get_row_class_cursor()'
1374            AS_FORMAT (as_xml, as_json, as_geojson) devuelve fila en el formato especificado. La row_class deberá
1375                        responder a esas funciones
1376
1377        Args:
1378            sql_str:
1379            *args_sql:
1380            **extra_params: {
1381                "row_class": clase que se utilizará para cada fila. Vease get_row_factory()
1382                "as_format": formato en el que se devuelve cada fila.
1383                    Las clases base row_cursor y row_table.
1384                    (vease get_row_class_cursor() y get_row_class_tab()) responden
1385                    por defecto a"as_xml()" y "as_json()"
1386                "geom_format": nombre función para formatear las geometrías SDO_GEOMETRY. (vease sdo_geom as_[format])
1387                "rowfactory": función rowfactory para crear las filas devueltas por el cursor
1388                "input_handler": función input_handler para el cursor (vease sdo_geom.get_sdo_input_handler())
1389            }
1390
1391        Returns:
1392            object (instancia que debería ser o heredar de las clases row_cursor o row_table)
1393        """
1394        return execute_fetch_sql(self.con_db,
1395                                 sql_str,
1396                                 *args_sql,
1397                                 **extra_params)
1398
1399    @print_to_log_exception(cx_Oracle.DatabaseError)
1400    def generator_rows_sql(self, sql_str, *args_sql, **extra_params):
1401        """
1402        Ejecuta consulta SQL de forma iterativa retornando cada fila como un objeto row_class (por defecto row_cursor)
1403
1404        Se puede informar **EXTRA_PARAMS con algunos de los siguientes parámetros:
1405            INPUT_HANDLER funcion que tratará los bindings de manera específica
1406            ROW_CLASS define que con que clase se devolverá cada fila. Por defecto la que devuleve la funcion
1407                      'apb_cx_oracle_spatial.get_row_class_cursor()'
1408            AS_FORMAT (as_xml, as_json, as_geojson, ...) devuelve fila en el formato especificado. La row_class deberá
1409                        responder a esas funciones
1410
1411        Args:
1412            sql_str:
1413            *args_sql:
1414            **extra_params: {
1415                "row_class": clase que se utilizará para cada fila. Vease get_row_factory()
1416                "as_format": formato en el que se devuelve cada fila.
1417                    Las clases base row_cursor y row_table.
1418                    (vease get_row_class_cursor() y get_row_class_tab()) responden
1419                    por defecto a"as_xml()" y "as_json()"
1420                "geom_format": nombre función para formatear las geometrías SDO_GEOMETRY. (vease sdo_geom as_[format])
1421                "rowfactory": función rowfactory para crear las filas devueltas por el cursor
1422                "input_handler": función input_handler para el cursor (vease sdo_geom.get_sdo_input_handler())
1423            }
1424
1425        Returns:
1426            object (instancia que debería ser o heredar de las clases row_cursor o row_table)
1427        """
1428        for reg in iter_execute_fetch_sql(self.con_db, sql_str, *args_sql,
1429                                          logger=self.logger,
1430                                          **extra_params):
1431            yield reg
1432
1433    def rows_sql(self, sql_str, *args_sql):
1434        """
1435        Vease funcion 'generator_rows_sql()'
1436        Args:
1437            sql_str:
1438            *args_sql:
1439
1440        Returns:
1441            list
1442        """
1443        return list(self.generator_rows_sql(sql_str, *args_sql))
1444
1445    def get_primary_key_table(self, nom_tab_or_view):
1446        """
1447        Retorna lista con las columnas que conforman la primary key de una tabla/vista
1448        Args:
1449            nom_tab_or_view:
1450
1451        Returns:
1452            list con campos clave
1453        """
1454        return get_pk_tab(self.con_db, nom_tab_or_view)
1455
1456    @print_to_log_exception(lanzar_exc=True)
1457    def get_dd_table(self, nom_tab_or_view):
1458        """
1459        Retorna instancia row_table con los tipos para cada columna
1460        Args:
1461            nom_tab_or_view:
1462
1463        Returns:
1464            object de clase row_table con los tipos de cada columna como valores
1465        """
1466        return get_row_desc_tab(self.con_db, nom_tab_or_view)
1467
1468    def generator_rows_table(self, nom_tab_or_view, filter_sql=None, *args_filter_sql, **extra_params):
1469        """
1470        Retorna los registros que cumplan con el FILTER_SQL sobre la tabla o vista indicada.
1471
1472        La tabla se puede referenciar en el filtro con el alias 'TAB'
1473
1474        Si el FILTER_SQL utiliza valores por binding (:1, :2,...) estos se indicaran por orden en ARGS_FILTER_SQL
1475
1476        Args:
1477            nom_tab_or_view: Nombre de la tabla o vista sobre la que se hará la consulta
1478            filter_sql: Filtre sobre la taula
1479            args_filter_sql: Valors en ordre de binding per passar
1480            extra_params: Vease generator_rows_sql()
1481
1482        Yields:
1483             row_table: regs. clase row_table (mirar get_row_class_tab())
1484        """
1485        for reg in self.generator_rows_sql(sql_tab(nom_tab_or_view,
1486                                                   filter_sql),
1487                                           *args_filter_sql,
1488                                           row_class=extra_params.pop(
1489                                               "row_class",
1490                                               get_row_class_tab(self.con_db, nom_tab_or_view)),
1491                                           **extra_params):
1492            yield reg
1493
1494    def generator_rows_interact_geom(self, nom_tab, a_sdo_geom, cols_geom=None, geom_format=None):
1495        """
1496        Retorna las filas de una tabla que interactuan con una geometria
1497
1498        Args:
1499            nom_tab: nombre de la tabla
1500            a_sdo_geom: geometria clase sdo_geom
1501            cols_geom (default=None): Lista con nombre de columnas geométricas sobre las que se quiere aplicar filtro
1502            geom_format:
1503        Yields:
1504            row_table: regs. clase row_table (mirar get_row_class_tab())
1505        """
1506        # Uso de " <>'FALSE'" por fallo de Oracle usando "= 'TRUE'"
1507        filter_interact_base = "SDO_ANYINTERACT({camp_geom}, :1) <> 'FALSE'"
1508
1509        if not cols_geom:
1510            cols_geom = get_tips_geom_tab(self.con_db, nom_tab).keys()
1511
1512        if cols_geom:
1513            filter_sql = " OR ".join([filter_interact_base.format(camp_geom=ng) for ng in cols_geom])
1514            for reg in self.generator_rows_table(nom_tab, filter_sql, a_sdo_geom.as_ora_sdo_geometry(),
1515                                                 geom_format=geom_format):
1516                yield reg
1517
1518    def rows_table(self, nom_tab_or_view, filter_sql=None, *args_filter_sql):
1519        """
1520        Vease funcion 'generator_rows_table()'
1521
1522        Args:
1523            nom_tab_or_view:
1524            filter_sql:
1525            *args_filter_sql:
1526
1527        Returns:
1528            dict
1529        """
1530        gen_tab = self.generator_rows_table(nom_tab_or_view,
1531                                            filter_sql,
1532                                            *args_filter_sql)
1533        pk_tab = self.get_primary_key_table(nom_tab_or_view)
1534        l_pk = len(pk_tab)
1535        if l_pk == 0:
1536            return [r for r in gen_tab]
1537        else:
1538            def f_key(r):
1539                return getattr(r, pk_tab[0])
1540
1541            if l_pk > 1:
1542                def f_key(r): return tuple(map(lambda nf: getattr(r, nf), pk_tab))
1543            return {f_key(r): r for r in gen_tab}
1544
1545    def row_table(self, nom_tab_or_view, filter_sql=None, *args_filter_sql, **extra_params):
1546        """
1547        Retorna primer registro para el FILTER_SQL sobre la tabla o vista indicada
1548        Si el FILTER_SQL utiliza valores por binding (:1, :2,...) estos se indicaran por orden en ARGS_FILTER_SQL
1549
1550        Args:
1551            nom_tab_or_view:
1552            filter_sql:
1553            *args_filter_sql:
1554            **extra_params:
1555
1556        Returns:
1557            object de la clase row_table o especificada en **extra_params['row_class']
1558        """
1559        gen = self.generator_rows_table(nom_tab_or_view,
1560                                        filter_sql,
1561                                        *args_filter_sql,
1562                                        **extra_params)
1563        return next(gen, None)
1564
1565    def row_table_at(self, nom_tab_or_view, *vals_key):
1566        """
1567        Devuelve row_tabla_class para el registro que de la tabla_vista que cumpla con la clave
1568
1569        Args:
1570            nom_tab_or_view:
1571            *vals_key:
1572
1573        Returns:
1574            object de la clase row_table o especificada en **extra_params['row_class']
1575        """
1576        return self.exist_row_tab(nom_tab_or_view,
1577                                  {nc: val for nc, val in zip(self.get_primary_key_table(nom_tab_or_view),
1578                                                              vals_key)})
1579
1580    def test_row_table(self, row_tab, a_sql, *args_sql):
1581        """
1582        Testea un registro de tabla (clase rwo_table) cumpla con sql indicado
1583
1584        Args:
1585            row_tab: registro de tabla en forma de clase row_table
1586            a_sql: string con sql a testear
1587
1588        Returns:
1589            bool: True o False según cumpla con el SQL indicado
1590        """
1591        sql_pk = dict_as_sql_bind_and_params(row_tab.pk_vals())
1592        query_sql = "{} AND ({})".format(sql_pk[0], a_sql)
1593
1594        ret = False
1595        if self.row_table(row_tab.nom_tab, query_sql, *(tuple(sql_pk[1]) + tuple(args_sql))):
1596            ret = True
1597
1598        return ret
1599
1600    def insert_row_tab(self, nom_tab, dict_vals_param=None, dict_vals_str=None, pasar_nulls=False):
1601        """
1602        Inserta registro en la tabla indicada. Los valores para cada columna se pasarán a través de dict_vals_param
1603        como bindings o a través de dict_vals_str directemente en el string del sql ejecutado
1604        Args:
1605            nom_tab: nombre de la tabla
1606            dict_vals_param: diccionario indexado por columnas-valores. Los valores se pasarán como bindings
1607            dict_vals_str: diccionario indexado por columnas-valores a asignar como strings. El valor se pasa
1608                        directamente como asignacion en la senetencia sql
1609            pasar_nulls: (opcional) por defecto False. Indica si los valores NULL se asignarán o no
1610
1611        Returns:
1612            row_table (si genera el registro) o False si va mal la operación
1613        """
1614        if not dict_vals_param:
1615            dict_vals_param = {}
1616        if not dict_vals_str:
1617            dict_vals_str = {}
1618
1619        ora_dict_vals_param = self.get_vals_tab_for_transdb(nom_tab, dict_vals_param, pasar_nulls=pasar_nulls)
1620
1621        if pasar_nulls:
1622            # Se revisa que en un campo geometrico se asigne None y por lo tanto se asigne valor via STR
1623            geoms_null = [ng for ng, val in ora_dict_vals_param.items()
1624                          if not val and self.get_tip_camp_geom(nom_tab, ng)]
1625            if geoms_null:
1626                keys_str = [nc.upper() for nc in dict_vals_str.keys()]
1627                for gn in geoms_null:
1628                    ora_dict_vals_param.pop(gn)
1629                    if gn.upper() not in keys_str:
1630                        dict_vals_str[gn.upper()] = "NULL"
1631
1632        params = []
1633        nom_camps = []
1634        vals_camps = []
1635        for nom_camp, val_camp in ora_dict_vals_param.items():
1636            if val_camp is None:
1637                continue
1638            nom_camps.append(nom_camp)
1639            vals_camps.append(":" + nom_camp)
1640            params.append(val_camp)
1641
1642        for nom_camp, val_camp_str in dict_vals_str.items():
1643            if val_camp_str is None:
1644                continue
1645            nom_camps.append(nom_camp)
1646            vals_camps.append(str(val_camp_str))
1647
1648        row_desc_tab = get_row_desc_tab(self.con_db, nom_tab)
1649        pk_binds = {k: new_cursor(self.con_db).var(ora_tip_camp) for k, ora_tip_camp in row_desc_tab.pk_vals().items()}
1650        if not pk_binds:
1651            pk_binds = {'ROWID': new_cursor(self.con_db).var(cx_Oracle.ROWID)}
1652        str_pk_camps = ",".join(pk_binds.keys())
1653        str_pk_binds = ",".join(list(map(lambda x: ":ret_" + str(x), pk_binds.keys())))
1654        params += list(pk_binds.values())
1655
1656        a_sql_res = f"insert into {nom_tab}({','.join(nom_camps)}) values({','.join(vals_camps)}) " \
1657                    f"returning {str_pk_camps} into {str_pk_binds}"
1658
1659        ok = self.exec_trans_db(a_sql_res, *params)
1660        if ok:
1661            pk_vals = {k: curs_var.getvalue(0)[0] for k, curs_var in pk_binds.items()}
1662            return self.exist_row_tab(nom_tab, pk_vals)
1663
1664        return ok
1665
1666    def update_row_tab(self, nom_tab, dict_clau_reg, dict_vals_param=None, dict_vals_str=None, pasar_nulls=None):
1667        """
1668        Actualiza registro en la tabla indicada que cunpla con la clave pasada por dict_clau_reg {clave:valor}
1669        Los valores para cada columna se pasarán a través de dict_vals_param como bindings o a través de
1670        dict_vals_str directemente en el string del sql ejecutado
1671
1672        Args:
1673            nom_tab: nombre de la tabla
1674            dict_clau_reg: diccionario indexado por clave-valor del registro a actualizar
1675            dict_vals_param: diccionario indexado por columnas-valores. Los valores se pasarán como bindings
1676            dict_vals_str: diccionario indexado por columnas-valores a asignar como strings. El valor se pasa
1677                        directamente como asignacion en la senetencia sql
1678            pasar_nulls: (opcional) por defecto False. Indica si los valores NULL se asignarán o no
1679
1680        Returns:
1681            row_table (si genera el registro) o False si va mal la operación
1682        """
1683        if not dict_vals_param:
1684            dict_vals_param = {}
1685        if not dict_vals_str:
1686            dict_vals_str = {}
1687
1688        ora_dict_clau_reg = self.get_vals_tab_for_transdb(nom_tab, dict_clau_reg)
1689        ora_dict_vals_param = self.get_vals_tab_for_transdb(nom_tab, dict_vals_param, pasar_nulls=pasar_nulls)
1690
1691        if pasar_nulls:
1692            # Se revisa que en un campo geometrico se asigne None y por lo tanto se asigne valor via STR
1693            geoms_null = [ng for ng, val in ora_dict_vals_param.items()
1694                          if not val and self.get_tip_camp_geom(nom_tab, ng)]
1695            if geoms_null:
1696                keys_str = [nc.upper() for nc in dict_vals_str.keys()]
1697                for gn in geoms_null:
1698                    ora_dict_vals_param.pop(gn)
1699                    if gn.upper() not in keys_str:
1700                        dict_vals_str[gn.upper()] = "NULL"
1701
1702        (sql_set_camps, params_set_camps) = dict_as_sql_bind_and_params(ora_dict_vals_param,
1703                                                                        ",", "=")
1704
1705        (query_clau, params_filter) = dict_as_sql_bind_and_params(ora_dict_clau_reg)
1706
1707        params = params_set_camps + params_filter
1708
1709        for nom_camp, val_camp_str in dict_vals_str.items():
1710            if sql_set_camps:
1711                sql_set_camps += " , "
1712            sql_set_camps += nom_camp + "=" + val_camp_str
1713
1714        ok = None
1715        if sql_set_camps:
1716            a_sql_res = f"update {nom_tab} set {sql_set_camps} where {query_clau}"
1717
1718            ok = self.exec_trans_db(a_sql_res, *params)
1719
1720            if ok:
1721                return self.exist_row_tab(nom_tab, dict_clau_reg)
1722
1723        return ok
1724
1725    def remove_row_tab(self, nom_tab, dict_clau_reg):
1726        """
1727        Borra registro en la tabla indicada que cunpla con la clave pasada por dict_clau_reg {clave:valor}
1728
1729        Args:
1730            nom_tab: nombre de la tabla
1731            dict_clau_reg: diccionario indexado por clave-valor del registro a actualizar
1732
1733        Returns:
1734            bool según vaya la operación
1735        """
1736        ora_dict_clau_reg = self.get_vals_tab_for_transdb(nom_tab, dict_clau_reg)
1737
1738        a_sql_tmpl = "delete {nom_tab} where {query_clau}"
1739
1740        (sql_filter, params) = dict_as_sql_bind_and_params(ora_dict_clau_reg)
1741
1742        a_sql_res = a_sql_tmpl.format(nom_tab=nom_tab,
1743                                      query_clau=sql_filter)
1744
1745        return self.exec_trans_db(a_sql_res, *params)
1746
1747    def exist_row_tab(self, nom_tab, dict_clau_reg, **extra_params):
1748        """
1749        Devuelve registro de la tabla indicada que cunpla con la clave pasada por dict_clau_reg {clave:valor}
1750
1751        Args:
1752            nom_tab: nombre de la tabla
1753            dict_clau_reg: diccionario indexado por clave-valor del registro a actualizar
1754            **extra_params:
1755
1756        Returns:
1757            object de la clase row_table o especificada en **extra_params['row_class']
1758        """
1759        ora_dict_clau_reg = self.get_vals_tab_for_transdb(nom_tab, dict_clau_reg)
1760
1761        (filter_sql, params) = dict_as_sql_bind_and_params(ora_dict_clau_reg, "and", "=")
1762
1763        return self.row_table(nom_tab, filter_sql, *params, **extra_params)
1764
1765    def get_vals_tab_for_transdb(self, nom_tab, dict_camps_vals, pasar_nulls=True):
1766        """
1767        Para un tabla y diccionario columnas-valores devuelve diccionario indexado por las columnas con los valores
1768        convertidos a formato cx_Oracle según tipo de cada columna en Oracle
1769        Args:
1770            nom_tab: nombre de la tabla
1771            dict_camps_vals: diccionario indexado por columnas-valor a convertir a formato cx_Oracle
1772            pasar_nulls: (opcional) por defecto convertirá los None a NULL de Oracle
1773
1774        Returns:
1775            dict indexado por columnas con los valores convertidos a tipo cx_Oracle
1776        """
1777        dd_tab = get_row_desc_tab(self.con_db, nom_tab)
1778
1779        # Retorna dict con los campos a pasar por parametro
1780        d_params = {}
1781
1782        # Los nombres de campo siempre se buscarán en mayúsculas
1783        dict_camps_vals = {k.upper(): v for k, v in dict_camps_vals.items()}
1784
1785        for camp, tip_camp in dd_tab.vals().items():
1786            if camp not in dict_camps_vals:
1787                continue
1788
1789            val_camp = dict_camps_vals.get(camp)
1790            if not pasar_nulls and val_camp is None:
1791                continue
1792
1793            if isinstance(val_camp, m_sdo_geom.sdo_geom):
1794                var = val_camp.as_ora_sdo_geometry()
1795            else:
1796                try:
1797                    var = new_cursor(self.con_db).var(tip_camp)
1798                    var.setvalue(0, val_camp)
1799                except:
1800                    var = val_camp
1801
1802            d_params[camp] = var
1803
1804        return d_params
1805
1806    @print_to_log_exception()
1807    def run_sql_script(self, filename):
1808        """
1809        Ejecuta slq script (filename) sobre SQLPLUS
1810
1811        Args:
1812            filename: path del sql script
1813
1814        Returns:
1815
1816        """
1817        user_ora = self.con_db.username
1818        ds_ora = self.con_db.dsn
1819        nom_con = self.nom_con_db
1820        psw_ora = self.__psw_con_db__
1821        if psw_ora is None:
1822            print("ERROR - Conexión '" + nom_con + "' no está añadida al gestor!!")
1823            return
1824
1825        with open(filename, 'rb') as a_file:
1826            a_sql_command = a_file.read()
1827
1828        con_db_str = user_ora + "/" + psw_ora + "@" + ds_ora
1829        sqlplus = Popen(['sqlplus', '-S', con_db_str], stdin=PIPE, stdout=PIPE, stderr=PIPE)
1830        # sqlplus.stdin.write(a_sql_command)
1831
1832        (stdout, stderr) = sqlplus.communicate(a_sql_command)
1833
1834        self.print_log("Resultado lanzar script '{}': \n"
1835                       "{}".format(filename,
1836                                   stdout.decode("utf-8")))
1837
1838        if sqlplus is not None:
1839            sqlplus.terminate()
1840
1841    @staticmethod
1842    def get_nom_obj_sql(nom_base, prefix="", sufix=""):
1843        """
1844        Retorna nombre propuesto con prefijo/sufijos formateado para que cumpla longitud máxima de 32 caracteres en
1845        objetos sql Oracle
1846
1847        Args:
1848            nom_base: nombre propuesto
1849            prefix: (opc) prefijo
1850            sufix: (opc) sufijo
1851
1852        Returns:
1853            str formateado
1854        """
1855        return x_sql_parser.get_nom_obj_sql(nom_base, prefix, sufix)
1856
1857    def iter_sdo_gtypes_vals_camp_tab(self, nom_taula, nom_camp):
1858        """
1859        Retorna los distintos tipos de Geometria (codigo entero que define el tipo SDO_GTYPE)
1860        que se encuentran dentro de la columna sdo_geometry de una tabla
1861
1862        Args:
1863            nom_taula: nombre de la tabla
1864            nom_camp: nombre campo geometrico
1865
1866        Returns:
1867            int definiendo tipo de geometría
1868        """
1869        sql_tip_geoms = f"select distinct(tab.{nom_camp}.Get_GType()) as tip_geom from {nom_taula} tab " \
1870                        f"where {nom_camp} is not null"
1871
1872        for reg in self.generator_rows_sql(sql_tip_geoms):
1873            yield reg.TIP_GEOM
1874
1875    def iter_distinct_vals_camp_tab(self, nom_taula, nom_camp, filter_sql=None):
1876        """
1877        Retorna los distintos valores de la columna de una tabla
1878
1879        Args:
1880            nom_taula (str): Nombre de tabla
1881            nom_camp (str): Nombre de campo
1882            filter_sql(str): Filtro SQL sobre la tabla indicada
1883
1884        Returns:
1885            {str}: Itera los distintos valores encontrados en el campo indicado
1886        """
1887        sql_distinct_vals = f"select distinct(tab.{nom_camp}) as VAL from {nom_taula} tab"
1888        if filter_sql:
1889            sql_distinct_vals += " where " + filter_sql
1890
1891        for reg in self.generator_rows_sql(sql_distinct_vals):
1892            yield reg.VAL
1893
1894    def get_tip_camp_geom(self, nom_tab_or_view, nom_camp_geom):
1895        """
1896        Retorna el tipo de campo geométrico (class_tip_geom) registrados en la global __class_tips_geom_ora
1897        para el campo indicado
1898
1899        Args:
1900            nom_tab_or_view: nombre tabla/vista
1901            nom_camp_geom: nombre campo geom
1902
1903        Returns:
1904            namedtuple: con atributos ['TABLE_NAME', 'COLUMN_NAME', 'GTYPE', 'SRID'])
1905        """
1906        tips_geom_tab = get_tips_geom_tab(self.con_db, nom_tab_or_view)
1907        if tips_geom_tab:
1908            return tips_geom_tab.get(nom_camp_geom.upper())
1909
1910    def get_epsg_for_srid(self, srid):
1911        """
1912        Rertorna WKT con la definicion del SRID dado
1913        """
1914        return self.callfunc_sql('SDO_CS.MAP_ORACLE_SRID_TO_EPSG', cx_Oracle.NUMBER, srid)
1915
1916    def get_gtype_camp_geom(self, nom_tab_or_view, nom_camp_geom):
1917        """
1918        Retorna el tipo GTYPE (int) de la geometria
1919
1920        Args:
1921            nom_tab_or_view: nombre tabla/vista
1922            nom_camp_geom: nombre campo geom
1923
1924        Returns:
1925            int
1926        """
1927        gtype = 0
1928        g_tip_ora = self.get_tip_camp_geom(nom_tab_or_view, nom_camp_geom)
1929        if g_tip_ora:
1930            gtype = GTYPES_ORA.index(g_tip_ora.GTYPE)
1931
1932        return gtype
1933
1934    @staticmethod
1935    def verificar_path_vector_file(nom_tab_or_view, dir, file_name, ext, zipped):
1936        """
1937        Compone el/los path para el/los vector_file de una tabla y determina si exists
1938        Args:
1939            nom_tab_or_view:
1940            dir:
1941            file_name:
1942            ext:
1943            zipped:
1944
1945        Returns:
1946            file_path (str), file_path_zip (str), exists (bool)
1947        """
1948        if file_name and not file_name.endswith(ext):
1949            file_name = ".".join((file_name, ext))
1950        elif not file_name:
1951            file_name = ".".join((nom_tab_or_view, ext)).lower()
1952
1953        file_path = os.path.join(dir, file_name)
1954        file_path_zip = None
1955        if zipped:
1956            file_path_zip = "{}.zip".format(os.path.splitext(file_path)[0])
1957
1958        exists = (os.path.exists(file_path) and not file_path_zip) or (file_path_zip and os.path.exists(file_path_zip))
1959
1960        return file_path, file_path_zip, exists
1961
1962    @print_to_log_exception()
1963    def create_json_tab_or_view(self, nom_tab_or_view, dir='.', file_name=None, overwrite=True, cols=None, zipped=True,
1964                                filter_sql=None, *args_sql):
1965        """
1966
1967        Args:
1968            nom_tab_or_view (str): Nombre tabla o vista
1969            dir (str):
1970            file_name (str):
1971            overwrite (bool):
1972            cols (list): columnas
1973            zipped (bool):
1974            filter_sql (str):
1975            *args_sql: lista de argumentos a pasar al filtro sql
1976        Returns:
1977            file_path (str)
1978        """
1979        file_path, file_path_zip, exists = self.verificar_path_vector_file(
1980            nom_tab_or_view, dir, file_name, "json", zipped)
1981
1982        if overwrite or not exists:
1983            # Se calculan las columnas para hacer get de la fila con el orden en las columnas de la tabla
1984            if not cols:
1985                dd_tab = self.get_dd_table(nom_tab_or_view)
1986                cols = dd_tab.cols
1987            sql = sql_tab(nom_tab_or_view,
1988                          filter_sql=filter_sql,
1989                          columns=cols)
1990
1991            file_path_res = vector_file_from_gen_ora_sql(file_path, "json", self.generator_rows_sql(sql, *args_sql),
1992                                                         zipped=zipped)
1993        else:
1994            file_path_res = file_path if not zipped else file_path_zip
1995
1996        return file_path_res
1997
1998    @print_to_log_exception()
1999    def create_csv_tab_or_view(self, nom_tab_or_view, dir='.', file_name=None, overwrite=True, cols=None, zipped=True,
2000                               filter_sql=None, *args_sql):
2001        """
2002
2003        Args:
2004            nom_tab_or_view (str): Nombre tabla o vista
2005            dir (str):
2006            file_name (str):
2007            overwrite (bool):
2008            cols (list): columnas
2009            zipped (bool):
2010            filter_sql (str):
2011            *args_sql: lista de argumentos a pasar al filtro sql
2012
2013        Returns:
2014            file_path_res (str)
2015        """
2016        file_path, file_path_zip, exists = self.verificar_path_vector_file(
2017            nom_tab_or_view, dir, file_name, "csv", zipped)
2018
2019        if overwrite or not exists:
2020            if not cols:
2021                dd_tab = self.get_dd_table(nom_tab_or_view)
2022                cols = dd_tab.cols
2023            sql = sql_tab(nom_tab_or_view,
2024                          filter_sql=filter_sql,
2025                          columns=cols)
2026
2027            # Para el formato geocsv que acepta GDAL se añade fichero con los tipos de columna
2028            tip_cols_csv = []
2029            for col in cols:
2030                r_tip_col = self.row_table("user_tab_columns",
2031                                           "table_name = :1 and column_name = :2",
2032                                           nom_tab_or_view.upper(), col.upper())
2033                dtype = r_tip_col.DATA_TYPE
2034                dlength = r_tip_col.DATA_LENGTH
2035                dprecision = r_tip_col.DATA_PRECISION
2036                dscale = r_tip_col.DATA_SCALE
2037
2038                if dtype == "DATE":
2039                    tip_cols_csv.append('"DateTime"')
2040                elif dtype == "FLOAT":
2041                    tip_cols_csv.append('"Real({}.{})"'.format(dlength, dprecision))
2042                elif dtype == "NUMBER":
2043                    if dscale and dscale != 0:
2044                        tip_cols_csv.append('"Real({}.{})"'.format(dprecision, dscale))
2045                    elif dprecision:
2046                        tip_cols_csv.append('"Integer({})"'.format(dprecision))
2047                    else:
2048                        tip_cols_csv.append('"Real(10.8)"')
2049                elif dtype == "SDO_GEOMETRY":
2050                    tip_cols_csv.append('"WKT"')
2051                else:
2052                    tip_cols_csv.append('"String({})"'.format(round(dlength * 1.25)))
2053
2054            file_path_res = vector_file_from_gen_ora_sql(file_path, "csv",
2055                                                         self.generator_rows_sql(sql, *args_sql, geom_format="as_wkt"),
2056                                                         zipped=zipped, cols_csv=cols, tip_cols_csv=tip_cols_csv)
2057        else:
2058            file_path_res = file_path if not zipped else file_path_zip
2059
2060        return file_path_res
2061
2062    @print_to_log_exception()
2063    def create_geojsons_tab_or_view(self, nom_tab_or_view, dir='.', file_name_prefix=None, by_geom=False,
2064                                    dir_topojson=None, overwrite=True, cols=None,
2065                                    filter_sql=None, *args_sql):
2066        """
2067
2068        Args:
2069            nom_tab_or_view (str): Nombre tabla (vigente o versionada) para entidad GIS
2070            dir (str="."):
2071            file_name_prefix (str=None): (opcional) prefijo del fichero
2072            by_geom (bool=False): (Opcional) si se querrán los geojsons por geometria. Si no se saca un unico geojson con
2073                            la columna geometry como una GeometryCollection si la tabla es multigeom
2074            dir_topojson (str=None): path donde irán las conversiones
2075            overwrite (bool=True):
2076            cols (list=None):
2077            filter_sql (str=None):
2078            *args_sql: lista de argumentos a pasar al filtro sql
2079
2080        Returns:
2081            ok (bool)
2082        """
2083        ext = "geo.json"
2084        sqls = {}
2085        dd_tab = self.get_dd_table(nom_tab_or_view)
2086        if not cols:
2087            cols = dd_tab.cols
2088
2089        if by_geom:
2090            c_alfas = [cn for cn in dd_tab.alfas() if cn in cols]
2091            c_geoms = [cn for cn in dd_tab.geoms() if cn in cols]
2092            for c_geom in c_geoms:
2093                sqls[c_geom] = sql_tab(nom_tab_or_view, filter_sql, c_alfas + [c_geom])
2094        else:
2095            sqls[None] = sql_tab(nom_tab_or_view, filter_sql, cols)
2096
2097        if not file_name_prefix:
2098            file_name_prefix = nom_tab_or_view
2099
2100        for ng, sql in sqls.items():
2101            file_name = file_name_prefix
2102            if ng:
2103                file_name = "-".join((file_name, ng))
2104
2105            file_name = ".".join((file_name, ext)).lower()
2106            file_path = os.path.join(dir, file_name)
2107
2108            if overwrite or not os.path.exists(file_path):
2109                file_path = vector_file_from_gen_ora_sql(file_path, "geojson",
2110                                                         self.generator_rows_sql(sql, *args_sql))
2111
2112            if by_geom and dir_topojson and file_path:
2113                tip_geom = getattr(dd_tab, ng).GTYPE
2114                simplify = True
2115                if tip_geom.endswith("POINT"):
2116                    simplify = False
2117
2118                topojson_utils.geojson_to_topojson(file_path, dir_topojson,
2119                                                   simplify=simplify,
2120                                                   overwrite=overwrite)
2121
2122        return True
2123
2124
2125if __name__ == '__main__':
2126    import fire
2127
2128    sys.exit(fire.Fire())