luminesce-sdk 2.2.13__py3-none-any.whl → 2.2.14__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- luminesce/api/historically_executed_queries_api.py +16 -16
- luminesce/api/multi_query_execution_api.py +8 -8
- luminesce/api/sql_background_execution_api.py +92 -92
- luminesce/api/sql_design_api.py +6 -6
- luminesce/api/sql_execution_api.py +56 -56
- luminesce/configuration.py +1 -1
- luminesce/models/available_field.py +1 -1
- luminesce/models/available_parameter.py +1 -1
- luminesce/models/case_statement_item.py +4 -4
- luminesce/models/certificate_state.py +2 -2
- luminesce/models/convert_to_view_data.py +1 -1
- luminesce/models/error_highlight_request.py +1 -1
- luminesce/models/field_design.py +1 -1
- luminesce/models/mappable_field.py +1 -1
- luminesce/models/options_csv.py +1 -1
- luminesce/models/query_designer_version.py +1 -1
- luminesce/models/view_parameter.py +1 -1
- {luminesce_sdk-2.2.13.dist-info → luminesce_sdk-2.2.14.dist-info}/METADATA +1 -1
- {luminesce_sdk-2.2.13.dist-info → luminesce_sdk-2.2.14.dist-info}/RECORD +20 -20
- {luminesce_sdk-2.2.13.dist-info → luminesce_sdk-2.2.14.dist-info}/WHEEL +0 -0
|
@@ -52,15 +52,15 @@ class SqlExecutionApi:
|
|
|
52
52
|
|
|
53
53
|
|
|
54
54
|
@overload
|
|
55
|
-
async def get_by_query_csv(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> str: # noqa: E501
|
|
55
|
+
async def get_by_query_csv(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> str: # noqa: E501
|
|
56
56
|
...
|
|
57
57
|
|
|
58
58
|
@overload
|
|
59
|
-
def get_by_query_csv(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
59
|
+
def get_by_query_csv(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
60
60
|
...
|
|
61
61
|
|
|
62
62
|
@validate_arguments
|
|
63
|
-
def get_by_query_csv(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
63
|
+
def get_by_query_csv(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
64
64
|
"""GetByQueryCsv: Execute Sql from the url returning CSV # noqa: E501
|
|
65
65
|
|
|
66
66
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -105,7 +105,7 @@ class SqlExecutionApi:
|
|
|
105
105
|
return self.get_by_query_csv_with_http_info(query, scalar_parameters, query_name, download, timeout, delimiter, escape, date_time_format, **kwargs) # noqa: E501
|
|
106
106
|
|
|
107
107
|
@validate_arguments
|
|
108
|
-
def get_by_query_csv_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
108
|
+
def get_by_query_csv_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
109
109
|
"""GetByQueryCsv: Execute Sql from the url returning CSV # noqa: E501
|
|
110
110
|
|
|
111
111
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -261,15 +261,15 @@ class SqlExecutionApi:
|
|
|
261
261
|
|
|
262
262
|
|
|
263
263
|
@overload
|
|
264
|
-
async def get_by_query_excel(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
264
|
+
async def get_by_query_excel(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
265
265
|
...
|
|
266
266
|
|
|
267
267
|
@overload
|
|
268
|
-
def get_by_query_excel(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
268
|
+
def get_by_query_excel(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
269
269
|
...
|
|
270
270
|
|
|
271
271
|
@validate_arguments
|
|
272
|
-
def get_by_query_excel(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
272
|
+
def get_by_query_excel(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
273
273
|
"""GetByQueryExcel: Execute Sql from the url returning an Excel file # noqa: E501
|
|
274
274
|
|
|
275
275
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -308,7 +308,7 @@ class SqlExecutionApi:
|
|
|
308
308
|
return self.get_by_query_excel_with_http_info(query, scalar_parameters, query_name, date_time_format, timeout, **kwargs) # noqa: E501
|
|
309
309
|
|
|
310
310
|
@validate_arguments
|
|
311
|
-
def get_by_query_excel_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
311
|
+
def get_by_query_excel_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
312
312
|
"""GetByQueryExcel: Execute Sql from the url returning an Excel file # noqa: E501
|
|
313
313
|
|
|
314
314
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -446,15 +446,15 @@ class SqlExecutionApi:
|
|
|
446
446
|
|
|
447
447
|
|
|
448
448
|
@overload
|
|
449
|
-
async def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> str: # noqa: E501
|
|
449
|
+
async def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> str: # noqa: E501
|
|
450
450
|
...
|
|
451
451
|
|
|
452
452
|
@overload
|
|
453
|
-
def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
453
|
+
def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
454
454
|
...
|
|
455
455
|
|
|
456
456
|
@validate_arguments
|
|
457
|
-
def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
457
|
+
def get_by_query_json(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
458
458
|
"""GetByQueryJson: Execute Sql from the url returning JSON # noqa: E501
|
|
459
459
|
|
|
460
460
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -493,7 +493,7 @@ class SqlExecutionApi:
|
|
|
493
493
|
return self.get_by_query_json_with_http_info(query, scalar_parameters, query_name, timeout, json_proper, **kwargs) # noqa: E501
|
|
494
494
|
|
|
495
495
|
@validate_arguments
|
|
496
|
-
def get_by_query_json_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
496
|
+
def get_by_query_json_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
497
497
|
"""GetByQueryJson: Execute Sql from the url returning JSON # noqa: E501
|
|
498
498
|
|
|
499
499
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -631,15 +631,15 @@ class SqlExecutionApi:
|
|
|
631
631
|
|
|
632
632
|
|
|
633
633
|
@overload
|
|
634
|
-
async def get_by_query_parquet(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
634
|
+
async def get_by_query_parquet(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
635
635
|
...
|
|
636
636
|
|
|
637
637
|
@overload
|
|
638
|
-
def get_by_query_parquet(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
638
|
+
def get_by_query_parquet(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
639
639
|
...
|
|
640
640
|
|
|
641
641
|
@validate_arguments
|
|
642
|
-
def get_by_query_parquet(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
642
|
+
def get_by_query_parquet(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
643
643
|
"""GetByQueryParquet: Execute Sql from the url returning a Parquet file # noqa: E501
|
|
644
644
|
|
|
645
645
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -676,7 +676,7 @@ class SqlExecutionApi:
|
|
|
676
676
|
return self.get_by_query_parquet_with_http_info(query, scalar_parameters, query_name, timeout, **kwargs) # noqa: E501
|
|
677
677
|
|
|
678
678
|
@validate_arguments
|
|
679
|
-
def get_by_query_parquet_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
679
|
+
def get_by_query_parquet_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
680
680
|
"""GetByQueryParquet: Execute Sql from the url returning a Parquet file # noqa: E501
|
|
681
681
|
|
|
682
682
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -808,15 +808,15 @@ class SqlExecutionApi:
|
|
|
808
808
|
|
|
809
809
|
|
|
810
810
|
@overload
|
|
811
|
-
async def get_by_query_pipe(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
811
|
+
async def get_by_query_pipe(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
812
812
|
...
|
|
813
813
|
|
|
814
814
|
@overload
|
|
815
|
-
def get_by_query_pipe(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
815
|
+
def get_by_query_pipe(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
816
816
|
...
|
|
817
817
|
|
|
818
818
|
@validate_arguments
|
|
819
|
-
def get_by_query_pipe(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
819
|
+
def get_by_query_pipe(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
820
820
|
"""GetByQueryPipe: Execute Sql from the url returning pipe-delimited # noqa: E501
|
|
821
821
|
|
|
822
822
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -857,7 +857,7 @@ class SqlExecutionApi:
|
|
|
857
857
|
return self.get_by_query_pipe_with_http_info(query, scalar_parameters, query_name, download, date_time_format, timeout, **kwargs) # noqa: E501
|
|
858
858
|
|
|
859
859
|
@validate_arguments
|
|
860
|
-
def get_by_query_pipe_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
860
|
+
def get_by_query_pipe_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
861
861
|
"""GetByQueryPipe: Execute Sql from the url returning pipe-delimited # noqa: E501
|
|
862
862
|
|
|
863
863
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1001,15 +1001,15 @@ class SqlExecutionApi:
|
|
|
1001
1001
|
|
|
1002
1002
|
|
|
1003
1003
|
@overload
|
|
1004
|
-
async def get_by_query_sqlite(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
1004
|
+
async def get_by_query_sqlite(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
1005
1005
|
...
|
|
1006
1006
|
|
|
1007
1007
|
@overload
|
|
1008
|
-
def get_by_query_sqlite(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
1008
|
+
def get_by_query_sqlite(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
1009
1009
|
...
|
|
1010
1010
|
|
|
1011
1011
|
@validate_arguments
|
|
1012
|
-
def get_by_query_sqlite(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
1012
|
+
def get_by_query_sqlite(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
1013
1013
|
"""GetByQuerySqlite: Execute Sql from the url returning SqLite DB # noqa: E501
|
|
1014
1014
|
|
|
1015
1015
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1046,7 +1046,7 @@ class SqlExecutionApi:
|
|
|
1046
1046
|
return self.get_by_query_sqlite_with_http_info(query, scalar_parameters, query_name, timeout, **kwargs) # noqa: E501
|
|
1047
1047
|
|
|
1048
1048
|
@validate_arguments
|
|
1049
|
-
def get_by_query_sqlite_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1049
|
+
def get_by_query_sqlite_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1050
1050
|
"""GetByQuerySqlite: Execute Sql from the url returning SqLite DB # noqa: E501
|
|
1051
1051
|
|
|
1052
1052
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1178,15 +1178,15 @@ class SqlExecutionApi:
|
|
|
1178
1178
|
|
|
1179
1179
|
|
|
1180
1180
|
@overload
|
|
1181
|
-
async def get_by_query_xml(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
1181
|
+
async def get_by_query_xml(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
1182
1182
|
...
|
|
1183
1183
|
|
|
1184
1184
|
@overload
|
|
1185
|
-
def get_by_query_xml(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
1185
|
+
def get_by_query_xml(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
1186
1186
|
...
|
|
1187
1187
|
|
|
1188
1188
|
@validate_arguments
|
|
1189
|
-
def get_by_query_xml(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
1189
|
+
def get_by_query_xml(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
1190
1190
|
"""GetByQueryXml: Execute Sql from the url returning XML # noqa: E501
|
|
1191
1191
|
|
|
1192
1192
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1225,7 +1225,7 @@ class SqlExecutionApi:
|
|
|
1225
1225
|
return self.get_by_query_xml_with_http_info(query, scalar_parameters, query_name, download, timeout, **kwargs) # noqa: E501
|
|
1226
1226
|
|
|
1227
1227
|
@validate_arguments
|
|
1228
|
-
def get_by_query_xml_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1228
|
+
def get_by_query_xml_with_http_info(self, query : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (must be one line only)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1229
1229
|
"""GetByQueryXml: Execute Sql from the url returning XML # noqa: E501
|
|
1230
1230
|
|
|
1231
1231
|
Returns data from a simple single-line query execution which is specified on the url. e.g. `select ^ from Sys.Field order by 1, 2`, returned in the format of the method name. The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1363,15 +1363,15 @@ class SqlExecutionApi:
|
|
|
1363
1363
|
|
|
1364
1364
|
|
|
1365
1365
|
@overload
|
|
1366
|
-
async def put_by_query_csv(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> str: # noqa: E501
|
|
1366
|
+
async def put_by_query_csv(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> str: # noqa: E501
|
|
1367
1367
|
...
|
|
1368
1368
|
|
|
1369
1369
|
@overload
|
|
1370
|
-
def put_by_query_csv(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
1370
|
+
def put_by_query_csv(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
1371
1371
|
...
|
|
1372
1372
|
|
|
1373
1373
|
@validate_arguments
|
|
1374
|
-
def put_by_query_csv(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
1374
|
+
def put_by_query_csv(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
1375
1375
|
"""PutByQueryCsv: Execute Sql from the body returning CSV # noqa: E501
|
|
1376
1376
|
|
|
1377
1377
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1416,7 +1416,7 @@ class SqlExecutionApi:
|
|
|
1416
1416
|
return self.put_by_query_csv_with_http_info(body, scalar_parameters, query_name, download, timeout_seconds, delimiter, escape, date_time_format, **kwargs) # noqa: E501
|
|
1417
1417
|
|
|
1418
1418
|
@validate_arguments
|
|
1419
|
-
def put_by_query_csv_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1419
|
+
def put_by_query_csv_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, delimiter : Annotated[Optional[StrictStr], Field( description="Delimiter string to override the default")] = None, escape : Annotated[Optional[StrictStr], Field( description="Escape character to override the default")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1420
1420
|
"""PutByQueryCsv: Execute Sql from the body returning CSV # noqa: E501
|
|
1421
1421
|
|
|
1422
1422
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1579,15 +1579,15 @@ class SqlExecutionApi:
|
|
|
1579
1579
|
|
|
1580
1580
|
|
|
1581
1581
|
@overload
|
|
1582
|
-
async def put_by_query_excel(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
1582
|
+
async def put_by_query_excel(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
1583
1583
|
...
|
|
1584
1584
|
|
|
1585
1585
|
@overload
|
|
1586
|
-
def put_by_query_excel(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
1586
|
+
def put_by_query_excel(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
1587
1587
|
...
|
|
1588
1588
|
|
|
1589
1589
|
@validate_arguments
|
|
1590
|
-
def put_by_query_excel(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
1590
|
+
def put_by_query_excel(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
1591
1591
|
"""PutByQueryExcel: Execute Sql from the body making an Excel file # noqa: E501
|
|
1592
1592
|
|
|
1593
1593
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1626,7 +1626,7 @@ class SqlExecutionApi:
|
|
|
1626
1626
|
return self.put_by_query_excel_with_http_info(body, scalar_parameters, query_name, date_time_format, timeout_seconds, **kwargs) # noqa: E501
|
|
1627
1627
|
|
|
1628
1628
|
@validate_arguments
|
|
1629
|
-
def put_by_query_excel_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1629
|
+
def put_by_query_excel_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.000` (Excel support for this is limited)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1630
1630
|
"""PutByQueryExcel: Execute Sql from the body making an Excel file # noqa: E501
|
|
1631
1631
|
|
|
1632
1632
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1771,15 +1771,15 @@ class SqlExecutionApi:
|
|
|
1771
1771
|
|
|
1772
1772
|
|
|
1773
1773
|
@overload
|
|
1774
|
-
async def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> str: # noqa: E501
|
|
1774
|
+
async def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> str: # noqa: E501
|
|
1775
1775
|
...
|
|
1776
1776
|
|
|
1777
1777
|
@overload
|
|
1778
|
-
def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
1778
|
+
def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
1779
1779
|
...
|
|
1780
1780
|
|
|
1781
1781
|
@validate_arguments
|
|
1782
|
-
def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
1782
|
+
def put_by_query_json(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
1783
1783
|
"""PutByQueryJson: Execute Sql from the body returning JSON # noqa: E501
|
|
1784
1784
|
|
|
1785
1785
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1818,7 +1818,7 @@ class SqlExecutionApi:
|
|
|
1818
1818
|
return self.put_by_query_json_with_http_info(body, scalar_parameters, query_name, timeout_seconds, json_proper, **kwargs) # noqa: E501
|
|
1819
1819
|
|
|
1820
1820
|
@validate_arguments
|
|
1821
|
-
def put_by_query_json_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1821
|
+
def put_by_query_json_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, json_proper : Annotated[Optional[StrictBool], Field(description="Should this be text/json (not json-encoded-as-a-string)")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
1822
1822
|
"""PutByQueryJson: Execute Sql from the body returning JSON # noqa: E501
|
|
1823
1823
|
|
|
1824
1824
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -1963,15 +1963,15 @@ class SqlExecutionApi:
|
|
|
1963
1963
|
|
|
1964
1964
|
|
|
1965
1965
|
@overload
|
|
1966
|
-
async def put_by_query_parquet(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
1966
|
+
async def put_by_query_parquet(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
1967
1967
|
...
|
|
1968
1968
|
|
|
1969
1969
|
@overload
|
|
1970
|
-
def put_by_query_parquet(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
1970
|
+
def put_by_query_parquet(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
1971
1971
|
...
|
|
1972
1972
|
|
|
1973
1973
|
@validate_arguments
|
|
1974
|
-
def put_by_query_parquet(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
1974
|
+
def put_by_query_parquet(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
1975
1975
|
"""PutByQueryParquet: Execute Sql from the body making a Parquet file # noqa: E501
|
|
1976
1976
|
|
|
1977
1977
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -2008,7 +2008,7 @@ class SqlExecutionApi:
|
|
|
2008
2008
|
return self.put_by_query_parquet_with_http_info(body, scalar_parameters, query_name, timeout_seconds, **kwargs) # noqa: E501
|
|
2009
2009
|
|
|
2010
2010
|
@validate_arguments
|
|
2011
|
-
def put_by_query_parquet_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2011
|
+
def put_by_query_parquet_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2012
2012
|
"""PutByQueryParquet: Execute Sql from the body making a Parquet file # noqa: E501
|
|
2013
2013
|
|
|
2014
2014
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -2147,15 +2147,15 @@ class SqlExecutionApi:
|
|
|
2147
2147
|
|
|
2148
2148
|
|
|
2149
2149
|
@overload
|
|
2150
|
-
async def put_by_query_pipe(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
2150
|
+
async def put_by_query_pipe(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
2151
2151
|
...
|
|
2152
2152
|
|
|
2153
2153
|
@overload
|
|
2154
|
-
def put_by_query_pipe(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
2154
|
+
def put_by_query_pipe(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
2155
2155
|
...
|
|
2156
2156
|
|
|
2157
2157
|
@validate_arguments
|
|
2158
|
-
def put_by_query_pipe(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
2158
|
+
def put_by_query_pipe(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
2159
2159
|
"""PutByQueryPipe: Execute Sql from the body making pipe-delimited # noqa: E501
|
|
2160
2160
|
|
|
2161
2161
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -2196,7 +2196,7 @@ class SqlExecutionApi:
|
|
|
2196
2196
|
return self.put_by_query_pipe_with_http_info(body, scalar_parameters, query_name, download, date_time_format, timeout_seconds, **kwargs) # noqa: E501
|
|
2197
2197
|
|
|
2198
2198
|
@validate_arguments
|
|
2199
|
-
def put_by_query_pipe_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2199
|
+
def put_by_query_pipe_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, date_time_format : Annotated[Optional[StrictStr], Field( description="Format to apply for DateTime data, leaving blank gives the Luminesce Exporter default, currently `yyyy-MM-dd HH:mm:ss.fff`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2200
2200
|
"""PutByQueryPipe: Execute Sql from the body making pipe-delimited # noqa: E501
|
|
2201
2201
|
|
|
2202
2202
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -2347,15 +2347,15 @@ class SqlExecutionApi:
|
|
|
2347
2347
|
|
|
2348
2348
|
|
|
2349
2349
|
@overload
|
|
2350
|
-
async def put_by_query_sqlite(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
2350
|
+
async def put_by_query_sqlite(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> bytearray: # noqa: E501
|
|
2351
2351
|
...
|
|
2352
2352
|
|
|
2353
2353
|
@overload
|
|
2354
|
-
def put_by_query_sqlite(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
2354
|
+
def put_by_query_sqlite(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> bytearray: # noqa: E501
|
|
2355
2355
|
...
|
|
2356
2356
|
|
|
2357
2357
|
@validate_arguments
|
|
2358
|
-
def put_by_query_sqlite(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
2358
|
+
def put_by_query_sqlite(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[bytearray, Awaitable[bytearray]]: # noqa: E501
|
|
2359
2359
|
"""PutByQuerySqlite: Execute Sql from the body returning SqLite DB # noqa: E501
|
|
2360
2360
|
|
|
2361
2361
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -2392,7 +2392,7 @@ class SqlExecutionApi:
|
|
|
2392
2392
|
return self.put_by_query_sqlite_with_http_info(body, scalar_parameters, query_name, timeout_seconds, **kwargs) # noqa: E501
|
|
2393
2393
|
|
|
2394
2394
|
@validate_arguments
|
|
2395
|
-
def put_by_query_sqlite_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2395
|
+
def put_by_query_sqlite_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2396
2396
|
"""PutByQuerySqlite: Execute Sql from the body returning SqLite DB # noqa: E501
|
|
2397
2397
|
|
|
2398
2398
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -2531,15 +2531,15 @@ class SqlExecutionApi:
|
|
|
2531
2531
|
|
|
2532
2532
|
|
|
2533
2533
|
@overload
|
|
2534
|
-
async def put_by_query_xml(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
2534
|
+
async def put_by_query_xml(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> str: # noqa: E501
|
|
2535
2535
|
...
|
|
2536
2536
|
|
|
2537
2537
|
@overload
|
|
2538
|
-
def put_by_query_xml(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
2538
|
+
def put_by_query_xml(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=True, **kwargs) -> str: # noqa: E501
|
|
2539
2539
|
...
|
|
2540
2540
|
|
|
2541
2541
|
@validate_arguments
|
|
2542
|
-
def put_by_query_xml(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
2542
|
+
def put_by_query_xml(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[str, Awaitable[str]]: # noqa: E501
|
|
2543
2543
|
"""PutByQueryXml: Execute Sql from the body returning XML # noqa: E501
|
|
2544
2544
|
|
|
2545
2545
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|
|
@@ -2578,7 +2578,7 @@ class SqlExecutionApi:
|
|
|
2578
2578
|
return self.put_by_query_xml_with_http_info(body, scalar_parameters, query_name, download, timeout_seconds, **kwargs) # noqa: E501
|
|
2579
2579
|
|
|
2580
2580
|
@validate_arguments
|
|
2581
|
-
def put_by_query_xml_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, StrictStr]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2581
|
+
def put_by_query_xml_with_http_info(self, body : Annotated[StrictStr, Field(..., description="LuminesceSql to Execute (may be multi-line)")], scalar_parameters : Annotated[Optional[Dict[str, Dict[str, StrictStr]]], Field(description="Json encoded dictionary of key-value pairs for scalar parameter values to use in the sql execution.")] = None, query_name : Annotated[Optional[StrictStr], Field( description="Name to apply to the query in logs and `Sys.Logs.HcQueryStart`")] = None, download : Annotated[Optional[StrictBool], Field(description="Makes this a file-download request (as opposed to returning the data in the response-body)")] = None, timeout_seconds : Annotated[Optional[StrictInt], Field(description="In seconds: <0 or > 175 → 175s (Maximum allowed), 0 → 120s")] = None, **kwargs) -> ApiResponse: # noqa: E501
|
|
2582
2582
|
"""PutByQueryXml: Execute Sql from the body returning XML # noqa: E501
|
|
2583
2583
|
|
|
2584
2584
|
For more complex LuminesceSql a PUT will allow for longer and line break delimited Sql, whic will be returned in the format of the method name. e.g.: ```sql @@cutoff = select #2020-02-01#; @issues = select Id, SortId, Summary, Created, Updated from Dev.Jira.Issue where Project='HC' and Created < @@cutoff and Updated > @@cutoff; select i.Id, i.SortId, i.Summary, LinkText, LinkedIssueId, LinkedIssueSortId, LinkedIssueSummary from @issues i inner join Dev.Jira.Issue.Link li on i.Id = li.IssueId ``` The following error codes are to be anticipated with standard Problem Detail reports: - 400 BadRequest - something failed with the execution or parsing of your query - 401 Unauthorized - 403 Forbidden # noqa: E501
|