@@ -324,6 +324,200 @@ def describe_slow_logs_with_http_info(self, body, **kwargs): # noqa: E501
324324 _request_timeout = params .get ('_request_timeout' ),
325325 collection_formats = collection_formats )
326326
327+ def generate_sql_from_nl (self , body , ** kwargs ): # noqa: E501
328+ """generate_sql_from_nl # noqa: E501
329+
330+ This method makes a synchronous HTTP request by default. To make an
331+ asynchronous HTTP request, please pass async_req=True
332+ >>> thread = api.generate_sql_from_nl(body, async_req=True)
333+ >>> result = thread.get()
334+
335+ :param async_req bool
336+ :param GenerateSQLFromNLRequest body: (required)
337+ :return: GenerateSQLFromNLResponse
338+ If the method is called asynchronously,
339+ returns the request thread.
340+ """
341+ kwargs ['_return_http_data_only' ] = True
342+ if kwargs .get ('async_req' ):
343+ return self .generate_sql_from_nl_with_http_info (body , ** kwargs ) # noqa: E501
344+ else :
345+ (data ) = self .generate_sql_from_nl_with_http_info (body , ** kwargs ) # noqa: E501
346+ return data
347+
348+ def generate_sql_from_nl_with_http_info (self , body , ** kwargs ): # noqa: E501
349+ """generate_sql_from_nl # noqa: E501
350+
351+ This method makes a synchronous HTTP request by default. To make an
352+ asynchronous HTTP request, please pass async_req=True
353+ >>> thread = api.generate_sql_from_nl_with_http_info(body, async_req=True)
354+ >>> result = thread.get()
355+
356+ :param async_req bool
357+ :param GenerateSQLFromNLRequest body: (required)
358+ :return: GenerateSQLFromNLResponse
359+ If the method is called asynchronously,
360+ returns the request thread.
361+ """
362+
363+ all_params = ['body' ] # noqa: E501
364+ all_params .append ('async_req' )
365+ all_params .append ('_return_http_data_only' )
366+ all_params .append ('_preload_content' )
367+ all_params .append ('_request_timeout' )
368+
369+ params = locals ()
370+ for key , val in six .iteritems (params ['kwargs' ]):
371+ if key not in all_params :
372+ raise TypeError (
373+ "Got an unexpected keyword argument '%s'"
374+ " to method generate_sql_from_nl" % key
375+ )
376+ params [key ] = val
377+ del params ['kwargs' ]
378+ # verify the required parameter 'body' is set
379+ if self .api_client .client_side_validation and ('body' not in params or
380+ params ['body' ] is None ): # noqa: E501
381+ raise ValueError ("Missing the required parameter `body` when calling `generate_sql_from_nl`" ) # noqa: E501
382+
383+ collection_formats = {}
384+
385+ path_params = {}
386+
387+ query_params = []
388+
389+ header_params = {}
390+
391+ form_params = []
392+ local_var_files = {}
393+
394+ body_params = None
395+ if 'body' in params :
396+ body_params = params ['body' ]
397+ # HTTP header `Accept`
398+ header_params ['Accept' ] = self .api_client .select_header_accept (
399+ ['application/json' ]) # noqa: E501
400+
401+ # HTTP header `Content-Type`
402+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
403+ ['application/json' ]) # noqa: E501
404+
405+ # Authentication setting
406+ auth_settings = ['volcengineSign' ] # noqa: E501
407+
408+ return self .api_client .call_api (
409+ '/GenerateSQLFromNL/2018-01-01/dbw/post/application_json/' , 'POST' ,
410+ path_params ,
411+ query_params ,
412+ header_params ,
413+ body = body_params ,
414+ post_params = form_params ,
415+ files = local_var_files ,
416+ response_type = 'GenerateSQLFromNLResponse' , # noqa: E501
417+ auth_settings = auth_settings ,
418+ async_req = params .get ('async_req' ),
419+ _return_http_data_only = params .get ('_return_http_data_only' ),
420+ _preload_content = params .get ('_preload_content' , True ),
421+ _request_timeout = params .get ('_request_timeout' ),
422+ collection_formats = collection_formats )
423+
424+ def list_slow_query_advice_api (self , body , ** kwargs ): # noqa: E501
425+ """list_slow_query_advice_api # noqa: E501
426+
427+ This method makes a synchronous HTTP request by default. To make an
428+ asynchronous HTTP request, please pass async_req=True
429+ >>> thread = api.list_slow_query_advice_api(body, async_req=True)
430+ >>> result = thread.get()
431+
432+ :param async_req bool
433+ :param ListSlowQueryAdviceApiRequest body: (required)
434+ :return: ListSlowQueryAdviceApiResponse
435+ If the method is called asynchronously,
436+ returns the request thread.
437+ """
438+ kwargs ['_return_http_data_only' ] = True
439+ if kwargs .get ('async_req' ):
440+ return self .list_slow_query_advice_api_with_http_info (body , ** kwargs ) # noqa: E501
441+ else :
442+ (data ) = self .list_slow_query_advice_api_with_http_info (body , ** kwargs ) # noqa: E501
443+ return data
444+
445+ def list_slow_query_advice_api_with_http_info (self , body , ** kwargs ): # noqa: E501
446+ """list_slow_query_advice_api # noqa: E501
447+
448+ This method makes a synchronous HTTP request by default. To make an
449+ asynchronous HTTP request, please pass async_req=True
450+ >>> thread = api.list_slow_query_advice_api_with_http_info(body, async_req=True)
451+ >>> result = thread.get()
452+
453+ :param async_req bool
454+ :param ListSlowQueryAdviceApiRequest body: (required)
455+ :return: ListSlowQueryAdviceApiResponse
456+ If the method is called asynchronously,
457+ returns the request thread.
458+ """
459+
460+ all_params = ['body' ] # noqa: E501
461+ all_params .append ('async_req' )
462+ all_params .append ('_return_http_data_only' )
463+ all_params .append ('_preload_content' )
464+ all_params .append ('_request_timeout' )
465+
466+ params = locals ()
467+ for key , val in six .iteritems (params ['kwargs' ]):
468+ if key not in all_params :
469+ raise TypeError (
470+ "Got an unexpected keyword argument '%s'"
471+ " to method list_slow_query_advice_api" % key
472+ )
473+ params [key ] = val
474+ del params ['kwargs' ]
475+ # verify the required parameter 'body' is set
476+ if self .api_client .client_side_validation and ('body' not in params or
477+ params ['body' ] is None ): # noqa: E501
478+ raise ValueError ("Missing the required parameter `body` when calling `list_slow_query_advice_api`" ) # noqa: E501
479+
480+ collection_formats = {}
481+
482+ path_params = {}
483+
484+ query_params = []
485+
486+ header_params = {}
487+
488+ form_params = []
489+ local_var_files = {}
490+
491+ body_params = None
492+ if 'body' in params :
493+ body_params = params ['body' ]
494+ # HTTP header `Accept`
495+ header_params ['Accept' ] = self .api_client .select_header_accept (
496+ ['application/json' ]) # noqa: E501
497+
498+ # HTTP header `Content-Type`
499+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
500+ ['application/json' ]) # noqa: E501
501+
502+ # Authentication setting
503+ auth_settings = ['volcengineSign' ] # noqa: E501
504+
505+ return self .api_client .call_api (
506+ '/ListSlowQueryAdviceApi/2018-01-01/dbw/post/application_json/' , 'POST' ,
507+ path_params ,
508+ query_params ,
509+ header_params ,
510+ body = body_params ,
511+ post_params = form_params ,
512+ files = local_var_files ,
513+ response_type = 'ListSlowQueryAdviceApiResponse' , # noqa: E501
514+ auth_settings = auth_settings ,
515+ async_req = params .get ('async_req' ),
516+ _return_http_data_only = params .get ('_return_http_data_only' ),
517+ _preload_content = params .get ('_preload_content' , True ),
518+ _request_timeout = params .get ('_request_timeout' ),
519+ collection_formats = collection_formats )
520+
327521 def modify_audit_log_config (self , body , ** kwargs ): # noqa: E501
328522 """modify_audit_log_config # noqa: E501
329523
@@ -420,3 +614,100 @@ def modify_audit_log_config_with_http_info(self, body, **kwargs): # noqa: E501
420614 _preload_content = params .get ('_preload_content' , True ),
421615 _request_timeout = params .get ('_request_timeout' ),
422616 collection_formats = collection_formats )
617+
618+ def slow_query_advice_task_history_api (self , body , ** kwargs ): # noqa: E501
619+ """slow_query_advice_task_history_api # noqa: E501
620+
621+ This method makes a synchronous HTTP request by default. To make an
622+ asynchronous HTTP request, please pass async_req=True
623+ >>> thread = api.slow_query_advice_task_history_api(body, async_req=True)
624+ >>> result = thread.get()
625+
626+ :param async_req bool
627+ :param SlowQueryAdviceTaskHistoryApiRequest body: (required)
628+ :return: SlowQueryAdviceTaskHistoryApiResponse
629+ If the method is called asynchronously,
630+ returns the request thread.
631+ """
632+ kwargs ['_return_http_data_only' ] = True
633+ if kwargs .get ('async_req' ):
634+ return self .slow_query_advice_task_history_api_with_http_info (body , ** kwargs ) # noqa: E501
635+ else :
636+ (data ) = self .slow_query_advice_task_history_api_with_http_info (body , ** kwargs ) # noqa: E501
637+ return data
638+
639+ def slow_query_advice_task_history_api_with_http_info (self , body , ** kwargs ): # noqa: E501
640+ """slow_query_advice_task_history_api # noqa: E501
641+
642+ This method makes a synchronous HTTP request by default. To make an
643+ asynchronous HTTP request, please pass async_req=True
644+ >>> thread = api.slow_query_advice_task_history_api_with_http_info(body, async_req=True)
645+ >>> result = thread.get()
646+
647+ :param async_req bool
648+ :param SlowQueryAdviceTaskHistoryApiRequest body: (required)
649+ :return: SlowQueryAdviceTaskHistoryApiResponse
650+ If the method is called asynchronously,
651+ returns the request thread.
652+ """
653+
654+ all_params = ['body' ] # noqa: E501
655+ all_params .append ('async_req' )
656+ all_params .append ('_return_http_data_only' )
657+ all_params .append ('_preload_content' )
658+ all_params .append ('_request_timeout' )
659+
660+ params = locals ()
661+ for key , val in six .iteritems (params ['kwargs' ]):
662+ if key not in all_params :
663+ raise TypeError (
664+ "Got an unexpected keyword argument '%s'"
665+ " to method slow_query_advice_task_history_api" % key
666+ )
667+ params [key ] = val
668+ del params ['kwargs' ]
669+ # verify the required parameter 'body' is set
670+ if self .api_client .client_side_validation and ('body' not in params or
671+ params ['body' ] is None ): # noqa: E501
672+ raise ValueError ("Missing the required parameter `body` when calling `slow_query_advice_task_history_api`" ) # noqa: E501
673+
674+ collection_formats = {}
675+
676+ path_params = {}
677+
678+ query_params = []
679+
680+ header_params = {}
681+
682+ form_params = []
683+ local_var_files = {}
684+
685+ body_params = None
686+ if 'body' in params :
687+ body_params = params ['body' ]
688+ # HTTP header `Accept`
689+ header_params ['Accept' ] = self .api_client .select_header_accept (
690+ ['application/json' ]) # noqa: E501
691+
692+ # HTTP header `Content-Type`
693+ header_params ['Content-Type' ] = self .api_client .select_header_content_type ( # noqa: E501
694+ ['application/json' ]) # noqa: E501
695+
696+ # Authentication setting
697+ auth_settings = ['volcengineSign' ] # noqa: E501
698+
699+ return self .api_client .call_api (
700+ '/SlowQueryAdviceTaskHistoryApi/2018-01-01/dbw/post/application_json/' , 'POST' ,
701+ path_params ,
702+ query_params ,
703+ header_params ,
704+ body = body_params ,
705+ post_params = form_params ,
706+ files = local_var_files ,
707+ response_type = 'SlowQueryAdviceTaskHistoryApiResponse' , # noqa: E501
708+ auth_settings = auth_settings ,
709+ async_req = params .get ('async_req' ),
710+ _return_http_data_only = params .get ('_return_http_data_only' ),
711+ _preload_content = params .get ('_preload_content' , True ),
712+ _request_timeout = params .get ('_request_timeout' ),
713+ collection_formats = collection_formats )
0 commit comments