teradataml 17.20.0.6__py3-none-any.whl → 20.0.0.0__py3-none-any.whl

teradataml/dataframe/copy_to.py

@@ -30,9 +30,10 @@ from teradatasql import OperationalError
 from teradataml.common.wrapper_utils import AnalyticsWrapperUtils
 from teradataml.utils.utils import execute_sql
 from teradataml.utils.validators import _Validators
+from teradatasqlalchemy.telemetry.queryband import collect_queryband
 
 
-
+@collect_queryband(queryband="CpToSql")
 def copy_to_sql(df, table_name,
                 schema_name=None, if_exists='append',
                 index=False, index_label=None,
@@ -408,7 +409,7 @@ def copy_to_sql(df, table_name,
                 warnings.warn(Messages.get_message(MessageCodes.IGNORE_ARGS_WARN,
                                                    'primary_index',
                                                    'timecode_column',
-                                                   'specified'))
+                                                   'specified'), stacklevel=2)
         else:
             ignored = []
             if timezero_date is not None: ignored.append('timezero_date')
@@ -422,7 +423,7 @@ def copy_to_sql(df, table_name,
                 warnings.warn(Messages.get_message(MessageCodes.IGNORE_ARGS_WARN,
                                                    ignored,
                                                    'timecode_column',
-                                                   'missing'))
+                                                   'missing'), stacklevel=2)
 
         # Unset schema_name when temporary is True since volatile tables are always in the user database
         if temporary is True:
@@ -430,7 +431,7 @@ def copy_to_sql(df, table_name,
                 warnings.warn(Messages.get_message(MessageCodes.IGNORE_ARGS_WARN,
                                                    'schema_name',
                                                    'temporary=True',
-                                                   'specified'))
+                                                   'specified'), stacklevel=2)
             schema_name = None
 
         # Validate DataFrame & related flags; Proceed only when True
@@ -550,6 +551,8 @@ def copy_to_sql(df, table_name,
 
                     # When index isn't saved & for non-PTI tables, to_sql insertion used (batch)
                     else:
+                        # Empty queryband buffer before SQL call.
+                        UtilFuncs._set_queryband()
                         df.to_sql(table_name, get_context(), if_exists='append', index=False, index_label=None,
                                   chunksize=chunksize, schema=schema_name)
 
@@ -591,6 +594,7 @@ def copy_to_sql(df, table_name,
         raise TeradataMlException(Messages.get_message(MessageCodes.COPY_TO_SQL_FAIL) + str(err),
                                   MessageCodes.COPY_TO_SQL_FAIL) from err
 
+
 def _check_table_name_conflict(df, table_name):
     """ 
     Check whether destination "table_name" matches with the teradataml dataframe parent nodes.
@@ -721,6 +725,7 @@ def _get_index_labels(df, index_label):
 
     return ind_names, ind_types
 
+
 def _validate_pti_copy_parameters(df, timecode_column, timebucket_duration,
                                   timezero_date, primary_time_index_name, columns_list,
                                   sequence_column, seq_max, types, index, index_label):
@@ -968,7 +973,7 @@ def _validate_column_type(df, col, col_arg, expected_types, types = None, index
                                       MessageCodes.INVALID_COLUMN_TYPE)
     # Else we need to copy without any casting
     elif isinstance(df, pd.DataFrame):
-        t = _get_sqlalchemy_mapping(str(df.dtypes[col]))
+        t = _get_sqlalchemy_mapping_types(str(df.dtypes[col]))
         if t not in expected_types:
             raise TeradataMlException(Messages.get_message(MessageCodes.INVALID_COLUMN_TYPE).
                                       format(col_arg, t, ' or '.join(expected_type.__visit_name__
@@ -1451,7 +1456,7 @@ def _extract_column_info(df, types = None, index = False, index_label = None):
     col_types = [types.get(col_name) if types and col_name in types else
                  TIMESTAMP(timezone=True) if pt.is_datetime64_ns_dtype(df.dtypes[key])
                                              and (df[col_name].dt.tz is not None)
-                 else _get_sqlalchemy_mapping(str(df.dtypes[key]))
+                 else _get_sqlalchemy_mapping_types(str(df.dtypes[key]))
                  for key, col_name in enumerate(list(df.columns))]
 
     ind_names = []
@@ -1461,11 +1466,12 @@ def _extract_column_info(df, types = None, index = False, index_label = None):
         ind_types = [types.get(ind_name) if types and ind_name in types
                      else TIMESTAMP(timezone=True) if pt.is_datetime64_ns_dtype(df.dtypes[key])
                                                       and (df[ind_name].dt.tz is not None)
-                     else _get_sqlalchemy_mapping(str(ind_types[key]))
+                     else _get_sqlalchemy_mapping_types(str(ind_types[key]))
                      for key, ind_name in enumerate(ind_names)]
 
     return col_names + ind_names, col_types + ind_types
 
+
 def _insert_from_dataframe(df, con, schema_name, table_name, index, chunksize,
                            is_pti=False, timecode_column=None, sequence_column=None,
                            match_column_order=True):
@@ -1551,6 +1557,8 @@ def _insert_from_dataframe(df, con, schema_name, table_name, index, chunksize,
                 '(' + ', '.join(['?' for i in range(len(col_names) + len(df.index.names)
                                                     if index is True else len(col_names))]) + ')')
 
+        # Empty queryband buffer before SQL call.
+        UtilFuncs._set_queryband()
         rowcount = 0
         # Iterate rows of DataFrame over new re-ordered columns
         for row_index, row in enumerate(df[col_names].itertuples(index=True)):
@@ -1583,6 +1591,7 @@ def _insert_from_dataframe(df, con, schema_name, table_name, index, chunksize,
     except Exception:
         raise
 
+
 def _get_pd_df_column_names(df):
     """
     Internal function to return the names of columns in a Pandas DataFrame.
@@ -1602,6 +1611,7 @@ def _get_pd_df_column_names(df):
     """
     return df.columns.tolist()
 
+
 def _get_sqlalchemy_mapping(key):
     """
     This is an internal function used to returns a SQLAlchemy Type Mapping
@@ -1614,7 +1624,7 @@ def _get_sqlalchemy_mapping(key):
         key : String representing Pandas type ('int64', 'object' etc.)
 
     RETURNS:
-        SQLAlchemy Type (Integer, String, Float, DateTime etc.)
+        SQLAlchemy Type Object(Integer, String, Float, DateTime etc.)
 
     RAISES:
         N/A
@@ -1633,12 +1643,12 @@ def _get_sqlalchemy_mapping(key):
 def _get_all_sqlalchemy_mappings():
     """
     This is an internal function used to return a dictionary of all SQLAlchemy Type Mappings.
-    It contains mappings from pandas data type to SQLAlchemyTypes
+    It contains mappings from pandas data type to objects of SQLAlchemy Types
 
     PARAMETERS:
 
     RETURNS:
-        dictionary { pandas_type : SQLAlchemy Type}
+        dictionary { pandas_type : SQLAlchemy Type Object}
 
     RAISES:
         N/A
@@ -1646,11 +1656,11 @@ def _get_all_sqlalchemy_mappings():
     EXAMPLES:
         _get_all_sqlalchemy_mappings()
     """
-    teradata_types_map = {'int32':INTEGER, 'int64':BIGINT,
+    teradata_types_map = {'int32':INTEGER(), 'int64':BIGINT(),
                           'object':VARCHAR(configure.default_varchar_size,charset='UNICODE'),
                           'O':VARCHAR(configure.default_varchar_size,charset='UNICODE'),
-                          'float64':FLOAT, 'float32':FLOAT, 'bool':BYTEINT,
-                          'datetime64':TIMESTAMP, 'datetime64[ns]':TIMESTAMP,
+                          'float64':FLOAT(), 'float32':FLOAT(), 'bool':BYTEINT(),
+                          'datetime64':TIMESTAMP(), 'datetime64[ns]':TIMESTAMP(),
                           'datetime64[ns, UTC]':TIMESTAMP(timezone=True),
                           'timedelta64[ns]':VARCHAR(configure.default_varchar_size,charset='UNICODE'),
                           'timedelta[ns]':VARCHAR(configure.default_varchar_size,charset='UNICODE')}
@@ -1658,6 +1668,62 @@ def _get_all_sqlalchemy_mappings():
     return teradata_types_map
 
 
+def _get_sqlalchemy_mapping_types(key):
+    """
+    This is an internal function used to return a SQLAlchemy Type Mapping
+    for a given Pandas DataFrame column Type.
+    Used for Table Object creation internally based on DF column info.
+
+    For an unknown key, String (Mapping to VARCHAR) is returned
+
+    PARAMETERS:
+        key : String representing Pandas type ('int64', 'object' etc.)
+
+    RETURNS:
+        SQLAlchemy Type (Integer, String, Float, DateTime etc.)
+
+    RAISES:
+        N/A
+
+    EXAMPLES:
+        _get_sqlalchemy_mapping_types(key = 'int64')
+    """
+    teradata_types_map = _get_all_sqlalchemy_types_mapping()
+
+    if key in teradata_types_map.keys():
+        return teradata_types_map.get(key)
+    else:
+        return VARCHAR(configure.default_varchar_size,charset='UNICODE')
+
+
+def _get_all_sqlalchemy_types_mapping():
+    """
+    This is an internal function used to return a dictionary of all SQLAlchemy Type Mappings.
+    It contains mappings from pandas data type to SQLAlchemyTypes
+
+    PARAMETERS:
+
+    RETURNS:
+        dictionary { pandas_type : SQLAlchemy Type}
+
+    RAISES:
+        N/A
+
+    EXAMPLES:
+        _get_all_sqlalchemy_types_mapping()
+    """
+    teradata_types_map = {'int32': INTEGER, 'int64': BIGINT,
+                          'object': VARCHAR(configure.default_varchar_size, charset='UNICODE'),
+                          'O': VARCHAR(configure.default_varchar_size, charset='UNICODE'),
+                          'float64': FLOAT, 'float32': FLOAT, 'bool': BYTEINT,
+                          'datetime64': TIMESTAMP, 'datetime64[ns]': TIMESTAMP,
+                          'datetime64[ns, UTC]': TIMESTAMP(timezone=True),
+                          'timedelta64[ns]': VARCHAR(configure.default_varchar_size, charset='UNICODE'),
+                          'timedelta[ns]': VARCHAR(configure.default_varchar_size, charset='UNICODE')}
+
+    return teradata_types_map
+
+
 def _validate_timezero_date(timezero_date):
     """
     Internal function to validate timezero_date specified when creating a

teradataml/dataframe/data_transfer.py

@@ -27,8 +27,10 @@ from teradataml.dataframe.copy_to import copy_to_sql, _create_table_object, \
 from teradataml.dataframe.dataframe_utils import DataFrameUtils as df_utils
 from teradataml.dbutils.dbutils import _create_table, _execute_query_and_generate_pandas_df
 from teradataml.utils.validators import _Validators
+from teradatasqlalchemy.telemetry.queryband import collect_queryband
 
 
+@collect_queryband(queryband="fstExprt")
 def fastexport(df, export_to="pandas", index_column=None,
                catch_errors_warnings=False, csv_file=None,
                **kwargs):
@@ -363,6 +365,8 @@ def fastexport(df, export_to="pandas", index_column=None,
                                  export_to, str(err)),
                                  MessageCodes.DATA_EXPORT_FAILED)
 
+
+@collect_queryband(queryband="rdCsv")
 def read_csv(filepath,
              table_name,
              types=None,
@@ -2036,6 +2040,8 @@ class _DataTransferUtils():
             err_dict['error_message'] = []
             warn_dict['error_message'] = []
 
+            # Empty queryband buffer before SQL call.
+            UtilFuncs._set_queryband()
             # Execute insert statement
             cur.execute(ins)
 
@@ -2562,6 +2568,8 @@ class _DataTransferUtils():
         insert_stmt = self._form_insert_query(table=table_name,
                                               column_names=column_names)
 
+        # Empty queryband buffer before SQL call.
+        UtilFuncs._set_queryband()
         try:
             conn = get_connection().connection
             cur = conn.cursor()