Enriching metadata for correct text-to-SQL technology for Amazon Athena

Extracting worthwhile insights from huge datasets is crucial for companies striving to achieve a aggressive edge. Enterprise information is introduced into information lakes and information warehouses to hold out analytical, reporting, and information science use instances utilizing AWS analytical companies like Amazon Athena, Amazon Redshift, Amazon EMR, and so forth. Amazon Athena gives interactive analytics service for analyzing the information in Amazon Easy Storage Service (Amazon S3). Amazon Redshift is used to investigate structured and semi-structured information throughout information warehouses, operational databases, and information lakes. Amazon EMR gives a giant information setting for information processing, interactive evaluation, and machine studying utilizing open supply frameworks corresponding to Apache Spark, Apache Hive, and Presto. These information processing and analytical companies help Structured Question Language (SQL) to work together with the information.

Writing SQL queries requires not simply remembering the SQL syntax guidelines, but in addition information of the tables metadata, which is information about desk schemas, relationships among the many tables, and doable column values. Giant language mannequin (LLM)-based generative AI is a brand new expertise pattern for comprehending a big corpora of data and helping with advanced duties. Can it additionally assist write SQL queries? The reply is sure.

Generative AI fashions can translate pure language questions into legitimate SQL queries, a functionality often known as text-to-SQL technology. Though LLMs can generate syntactically right SQL queries, they nonetheless want the desk metadata for writing correct SQL question. On this submit, we show the important function of metadata in text-to-SQL technology by way of an instance carried out for Amazon Athena utilizing Amazon Bedrock. We talk about the challenges in sustaining the metadata in addition to methods to beat these challenges and enrich the metadata.

Resolution overview

This submit demonstrates text-to-SQL technology for Athena utilizing an instance carried out utilizing Amazon Bedrock. We use Anthropic’s Claude 2.1 basis mannequin (FM) in Amazon Bedrock because the LLM. Amazon Bedrock fashions are invoked utilizing Amazon SageMaker. Working examples are designed to show how numerous particulars included within the metadata influences the SQL generated by the mannequin. These examples use artificial datasets created in AWS Glue and Amazon S3. After we evaluation the importance of those metadata particulars, we’ll delve into the challenges encountered in gathering the required degree of metadata. Subsequently, we’ll discover methods for overcoming these challenges.

The examples carried out within the workflow are illustrated within the following diagram.

Determine 1. The answer structure and workflow.

The workflow follows the next sequence:

1. A person asks a text-based query which will be answered by querying related AWS Glue tables by way of Athena.
2. Desk metadata is fetched from AWS Glue.
3. The tables’ metadata and SQL producing directions are added to the immediate template. The Claude AI mannequin is invoked by passing the immediate and the mannequin parameters.
4. The Claude AI mannequin interprets the person intent (query) to SQL primarily based on the directions and tables’ metadata.
5. The generated Athena SQL question is run.
6. The generated Athena SQL question and the SQL question outcomes are returned to the person.

Stipulations

These conditions are given If you wish to do that instance your self. You’ll be able to skip this conditions part if you wish to perceive the instance with out implementing it. The instance facilities on invoking Amazon Bedrock fashions utilizing SageMaker, so we have to arrange just a few assets in an AWS Account. The related CloudFormation template, Jupyter Notebooks, and particulars of launching the required AWS companies are lined on this part. The CloudFormation template creates the SageMaker occasion with the required S3 bucket and IAM function permissions to run AWS Glue instructions, Athena SQL, and invoke Amazon Bedrock AI fashions. The 2 Jupyter Notebooks (0_create_tables_with_metadata.ipynb and 1_text-to-sql-for-athena.ipynb) present working code snippets to create the required tables and generate the SQL utilizing the Claude AI mannequin on Amazon Bedrock.

Granting Anthropic’s Claude permissions on Amazon Bedrock 

• Have an AWS account and sign up utilizing the AWS Administration Console.
• Change the AWS Area to US West (Oregon).
• Navigate to the AWS Service Catalog console and select Amazon Bedrock.
• On the Amazon Bedrock console, select Mannequin Entry within the navigation pane.
• Select Handle mannequin entry.
• Choose the Claude
• Select Request mannequin entry in case you’re requesting the mannequin entry for the primary time. In any other case select Save Modifications.

Deploying the CloudFormation stack

After launching the CloudFormation stack:

• On the Create stack web page, select Subsequent
• On the Specify stack particulars web page, select Subsequent
• On the Configure stack choices web page, select Subsequent
• On the Assessment and create web page, choose I acknowledge that AWS CloudFormation may create IAM assets
• Select Submit

Downloading Jupyter Notebooks to  SageMaker 

• Within the AWS Administration Console, select the identify of the at the moment displayed Area and alter it to US West (Oregon).
• Navigate to the AWS Service Catalog console and select Amazon SageMaker.
• On the Amazon SageMaker console, select Pocket book within the navigation pane.
• Select Pocket book cases.
• Choose the SageMakerNotebookInstance created by the texttosqlmetadata CloudFormation stack.
• Underneath Actions, select Open Jupyter
• Navigate to Jupyter console, choose New, after which select Console.
• Run the next Shell script instructions within the console to repeat the Jupyter Notebooks.

  cd /residence/ec2-user/SageMaker
  BASE_S3_PATH="s3://aws-blogs-artifacts-public/artifacts/BDB-4265"
  aws s3 cp "${BASE_S3_PATH}/0_create_tables_with_metadata.ipynb" ./
  aws s3 cp "${BASE_S3_PATH}/1_text_to_sql_for_athena.ipynb" ./
  

• Open every downloaded Pocket book and replace the values of the athena_results_bucket, aws_region, and athena_workgroup variables primarily based on the outputs from the texttosqlmetadata CloudFormation

Resolution implementation

If you wish to do that instance your self, strive the CloudFormation template supplied within the earlier part. Within the subsequent sections, we’ll illustrate how every factor of the metadata included within the immediate influences the SQL question generated by the mannequin.

1. The steps within the 0_create_tables_with_metadata.ipynb Jupyter Pocket book create Amazon S3 recordsdata with artificial information for worker and division datasets, creates employee_dtls and department_dtls Glue tables pointing to these S3 buckets, and extracts the next metadata for these two tables.

   CREATE EXTERNAL TABLE employee_dtls (
   	id int COMMENT 'Worker id',
   	identify string COMMENT 'Worker identify',
   	age int COMMENT 'Worker age',
   	dept_id int COMMENT 'Worker Departments ID',
   	emp_category string COMMENT 'Worker class. Incorporates TEMP For non permanent, PERM for everlasting, CONTR for contractors ',
   	location_id int COMMENT 'Location identifier of the Worker',
   	joining_date date COMMENT 'Becoming a member of date of the Worker',
   	CONSTRAINT pk_1 PRIMARY KEY  (id) ,
   	CONSTRAINT FK_1 FOREIGN KEY (dept_id) REFERENCES department_dtls(id)
   ) 
   PARTITIONED BY (
   	region_id string COMMENT 'Area identifier. Incorporates AMER for Americas, EMEA for Europe, the Center East, and Africa, APAC for Asia Pacific nations'
   );
   
   CREATE EXTERNAL TABLE department_dtls (
   	id int COMMENT 'Division id',
   	identify string COMMENT 'Division identify',
   	location_id int COMMENT 'Location identifier of the Division'
   )

2. The metadata extracted within the earlier step gives column descriptions. For the region_id partition column and emp_category column, the outline gives doable values together with their which means. The metadata additionally has international key constraint particulars. AWS Glue doesn’t present a option to specify the first key and international key constraints, so use customized keys within the AWS Glue table-level parameters as an alternative choice to collect main key and international keys whereas creating the AWS Glue desk.

   # Outline the desk schema
   employee_table_input = {
       'Title': employee_table_name,
       'PartitionKeys': [
           {'Name': 'region_id', 'Type': 'string', 'Comment': 'Region identifier. Contains AMER for Americas, EMEA for Europe, the Middle East, and Africa, APAC for Asia Pacific countries'}
       ],
       'StorageDescriptor': {
           'Columns': [
               {'Name': 'id', 'Type': 'int', 'Comment': 'Employee id'},
          …
           ],
           'Location': employee_s3_path,
        …
       'TableType': 'EXTERNAL_TABLE',
       'Parameters': {
           'classification': 'csv',
           'primary_key': 'CONSTRAINT pk_1 PRIMARY KEY  (id)',
           'foreign_key_1': 'CONSTRAINT FK_1 FOREIGN KEY (dept_id) REFERENCES department_dtls(id)'          
       }
   }
   
   # Create the desk
   response = glue_client.create_table(DatabaseName=database_name, TableInput=employee_table_input)
   

3. The steps within the 1_text-to-sql-for-athena.ipynb Jupyter pocket book create the next wrapper perform to work together with Claude FM on Amazon Bedrock to generate SQL primarily based on user-provided textual content wrapped up in a immediate. This perform arduous codes the mannequin’s parameters and mannequin ID for demonstrating the fundamental performance.

   def interactWithClaude(immediate):
   
       physique = json.dumps(
           {
               "immediate": immediate,
               "max_tokens_to_sample": 2048,
               "temperature": 1,
               "top_k": 250,
               "top_p": 0.999,
               "stop_sequences": [],
           }
       )
       modelId = "anthropic.claude-v2"  
       settle for = "utility/json"
       contentType = "utility/json"
       response = bedrock_client.invoke_model(
           physique=physique, modelId=modelId, settle for=settle for, contentType=contentType
       )
       response_body = json.masses(response.get("physique").learn())
       response_text_claude = response_body.get("completion")
       return response_text_claude

4. Outline the next set of directions for producing Athena SQL question. These SQL producing directions specify which compute engine the SQL question ought to run on and different directions to information the mannequin in producing the SQL question. These directions are included within the immediate despatched to the Bedrock mannequin.

   athena_sql_generating_instructions = """
   Learn database schema contained in the <database_schema></database_schema> tags which incorporates a listing of desk names and their schemas to do the next:
       1. Create a syntactically right AWS Athena question to reply the query.
       2. For tables with partitions, embody the filters on the related partition columns.
       3. Embrace solely related columns for the given query.
       4. Use solely the column names which are listed within the schema description. 
       5. Qualify column names with the desk identify.
       6. Keep away from joins to a desk if there isn't a column required from the desk.
       7. Convert Strings to Date sort whereas filtering on Date sort columns
       8. Return the sql question contained in the <SQL></SQL> tab.
   """

5. Outline completely different immediate templates for demonstrating the significance of metadata in text-to-SQL technology. These templates have placeholders for SQL question producing directions and tables metadata.

   athena_prompt1 = """
   Human:  You might be an AWS Athena question skilled whose output is a legitimate sql question. You might be given the next Directions for constructing the AWS Athena question.
   <Directions>
   {instruction_dtls}
   </Directions>
           
   Solely use the next tables outlined throughout the database_schema and table_schema XML-style tags:
   
   <database_schema>
   <table_schema>
   CREATE EXTERNAL TABLE employee_dtls (
     id int,
     identify string,
     age int ,
     dept_id int,
     emp_category string ,
     location_id int ,
     joining_date date
   ) PARTITIONED BY (
     region_id string
     )
   </table_schema>
   
   <table_schema>
   CREATE EXTERNAL TABLE department_dtls (
     id int,
     identify string ,
     location_id int 
   )
   </table_schema>
   </database_schema>
   
   Query: {query}
   
   Assistant: 
   """

6. Generate the ultimate immediate by passing the query and instruction particulars as arguments to the immediate template. Then, invoke the mannequin.

   question_asked = "Listing of everlasting workers who work in North America and  joined after Jan 1 2024"
   prompt_template_for_query_generate = PromptTemplate.from_template(athena_prompt1)
   prompt_data_for_query_generate = prompt_template_for_query_generate.format(query=question_asked,instruction_dtls=athena_sql_generating_instructions)
   llm_generated_response = interactWithClaude(prompt_data_for_query_generate)
   print(llm_generated_response.change("<sql>", "").change("</sql>", " ")  )
   

7. The mannequin generates the SQL question for the person query through the use of the directions and desk particulars supplied within the immediate.

   SELECT employee_dtls.id, employee_dtls.identify, employee_dtls.age, employee_dtls.dept_id, employee_dtls.emp_category
   FROM employee_dtls 
   WHERE employee_dtls.region_id = 'NA' 
     AND employee_dtls.emp_category = 'everlasting'
     AND employee_dtls.joining_date > CAST('2024-01-01' AS DATE)
   

Significance of prompts and metadata in text-to-SQL technology

Understanding the small print of tables and the information they comprise is crucial for each human SQL consultants and generative AI-based text-to-SQL technology. These particulars, collectively often known as metadata, present essential context for writing SQL queries. For the text-to-SQL instance carried out within the earlier part, we used prompts to convey particular directions and desk metadata to the mannequin, enabling it to carry out person duties successfully. A query arises on what degree of particulars we have to embody within the desk metadata. To make clear this level, we requested the mannequin to generate SQL question for a similar query 3 times with completely different prompts every time.

Immediate with no metadata

For the primary check, we used a fundamental immediate containing simply the SQL producing directions and no desk metadata. The essential immediate helped the mannequin generate a SQL question for the given query, nevertheless it’s not useful as a result of the mannequin made assumptions about desk names, column names, and literal values used within the filter expressions.

Query: Listing of everlasting workers who work in North America and joined after January 1, 2024.

Immediate definition:

Human: You might be an Amazon Athena question skilled whose output is a legitimate sql question. You might be given the next Directions for constructing the Amazon Athena question.
<Directions>
{instruction_dtls}
</Directions>

Query: {query}
Assistant:

SQL question generated:

SELECT emp.employee_id, emp.first_name, emp.last_name, emp.department_id
FROM worker emp
WHERE emp.contract="Everlasting"
AND emp.area = 'North America'
AND CAST(emp.start_date AS  DATE) > CAST('2024-01-01' AS DATE)

Immediate with fundamental metadata

For fixing the issue of assumed desk names and column names, we added desk metadata in DDL format within the second immediate. Because of this, the mannequin used the proper column names and information varieties and restricted the DATE casting to a literal string worth. It acquired the SQL question syntactically right, however one situation stays: the mannequin assumed the literal values used within the filter expressions.

Query: Listing of everlasting workers who work in North America and joined after January 1, 2024.

Immediate definition:

Human: You might be an Amazon Athena question skilled whose output is a legitimate sql question. You might be given the next Directions for constructing the Amazon Athena question.
<Directions>
{instruction_dtls}
</Directions>

Solely use the next tables outlined throughout the database_schema and table_schema XML-style tags:

<database_schema>
<table_schema>
CREATE EXTERNAL TABLE employee_dtls (
  id int,
  identify string,
  age int ,
  dept_id int,
  emp_category string ,
  location_id int ,
  joining_date date
) PARTITIONED BY (
  region_id string
  )
</table_schema>

<table_schema>
CREATE EXTERNAL TABLE department_dtls (
  id int,
  identify string ,
  location_id int 
)
</table_schema>
</database_schema>

Query: {query}
Assistant:

SQL question generated:

SELECT employee_dtls.id, employee_dtls.identify, employee_dtls.age, employee_dtls.dept_id, employee_dtls.emp_category
FROM employee_dtls 
WHERE employee_dtls.region_id = 'NA' 
  AND employee_dtls.emp_category = 'everlasting'
  AND employee_dtls.joining_date > CAST('2024-01-01' AS DATE)

Immediate with enriched metadata

Now we have to work out easy methods to present the doable values of a column to the mannequin. A method might be together with metadata within the column for low cardinality columns. So we added column descriptions together with doable values within the third immediate. Because of this, the mannequin included the proper literal values within the filter expressions and gave correct SQL question.

Query: Listing of everlasting workers who work in North America and joined after Jan 1, 2024.

Immediate definition:

Human: You might be an Amazon Athena question skilled whose output is a legitimate sql question. You might be given the next Directions for constructing the Amazon Athena question.
<Directions>
{instruction_dtls}
</Directions>

Solely use the next tables outlined throughout the database_schema and table_schema XML-style tags:

<database_schema>
<table_schema>
CREATE EXTERNAL TABLE employee_dtls (
id int COMMENT 'Worker id',
identify string COMMENT 'Worker identify',
age int COMMENT 'Worker age',
dept_id int COMMENT 'Worker Departments ID',
emp_category string COMMENT 'Worker class. Incorporates TEMP For non permanent, PERM for everlasting, CONTR for contractors ',
location_id int COMMENT 'Location identifier of the Worker',
joining_date date  COMMENT 'Worker becoming a member of date',
CONSTRAINT pk_1 PRIMARY KEY  (id) ,
CONSTRAINT FK_1 FOREIGN KEY (dept_id) REFERENCES department_dtls(id)
) PARTITIONED BY (
region_id string COMMENT 'Area identifier. Incorporates AMER for Americas, EMEA for Europe, the Center East, and Africa, APAC for Asia Pacific nations'
)
</table_schema>

<table_schema>
CREATE EXTERNAL TABLE department_dtls (
id int COMMENT 'Division id',
identify string COMMENT 'Division identify',
location_id int COMMENT 'Location identifier of the Division'
)
</table_schema>
</database_schema>

Query: {query}
Assistant:

SQL question generated:

SELECT employee_dtls.id, 
employee_dtls.identify
FROM employee_dtls 
WHERE employee_dtls.emp_category = 'PERM'
  AND employee_dtls.region_id = 'AMER' 
  AND employee_dtls.joining_date > CAST('2024-01-01' AS DATE)

Immediate with international key constraints within the Metadata

Word that after we added the finer particulars to the metadata of the third immediate, we included international key constraints as effectively. That is accomplished to assist the mannequin generate SQL for superior queries that require joins. Including international key constraints to the metadata helps the mannequin determine the proper columns for use within the be a part of situations. To show this level, we requested the mannequin to write down SQL for exhibiting division particulars together with the worker particulars. For exhibiting the division particulars, we want the department_dtls desk. The mannequin added department_dtls desk to the SQL question and recognized the fitting columns for the be a part of situation primarily based on international key constraint particulars included within the metadata.

Query: Listing of everlasting workers who work in North America and joined after Jan 1, 2024.

SQL question generated:

SELECT
  employee_dtls.identify AS employee_name,
  employee_dtls.age,
  department_dtls.identify AS department_name
FROM employee_dtls 
JOIN department_dtls 
  ON employee_dtls.dept_id = department_dtls.id
WHERE 
  employee_dtls.emp_category = 'PERM'
  AND employee_dtls.region_id = 'AMER' 
  AND employee_dtls.joining_date > CAST('2024-01-01' AS DATE)

Further observations

Although the mannequin included related worker attributes within the SELECT clause, the precise checklist of attributes it included different every time. Even for a similar immediate definition, the mannequin supplied a various checklist of attributes. The mannequin randomly used one of many two approaches for casting the string literal worth so far sort. The primary strategy makes use of CAST('2024-01-01' AS DATE) and the second strategy makes use of DATE '2024-01-01'.

Challenges in sustaining the metadata

Now that you simply perceive how sustaining detailed metadata together with international key constraints helps the mannequin in producing correct SQL queries, let’s talk about how one can collect the required particulars of desk metadata. The information lake and database catalogs help gathering and querying metadata, together with desk and column descriptions. Nonetheless, ensuring that these descriptions are correct and up-to-date poses a number of sensible challenges, corresponding to:

1. Creating database objects with helpful descriptions requires collaboration between technical and enterprise groups to write down detailed and significant descriptions. As tables endure schema adjustments, updating metadata for every change will be time-consuming and requires effort.
2. Sustaining lists of doable values for the columns requires steady updates.
3. Including information transformation particulars to metadata will be difficult due to the dispersed nature of this data throughout information processing pipelines, making it troublesome to extract and incorporate into table-level metadata.
4. Including information lineage particulars to metadata faces challenges due to the fragmented nature of this data throughout information processing pipelines, making extraction and integration into table-level metadata advanced.

Particular to the AWS Glue Information Catalog, extra challenges come up, corresponding to the next:

1. Creating AWS Glue tables by way of crawlers doesn’t routinely generate desk or column descriptions, requiring handbook updates to desk definitions from the AWS Glue console.
2. Not like conventional relational databases, AWS Glue tables don’t explicitly outline or implement main keys or international keys. AWS Glue tables function on a schema-on-read foundation, the place the schema is inferred from the information when querying. Due to this fact, there’s no direct help for specifying main keys, international keys, or column descriptions in AWS Glue tables like there may be in conventional databases.

Enriching the metadata

Listed right here some methods you could overcome the beforehand talked about challenges in sustaining the metadata.

• Improve the desk and column descriptions: Documenting desk and column descriptions requires a superb understanding of the enterprise course of, terminology, acronyms, and area information. The next are the completely different strategies you need to use to get these desk and column descriptions into the AWS Glue Information Catalog.
  • Use generative AI to generate higher documentation: Enterprises typically doc their enterprise processes, terminologies, and acronyms and make them accessible by way of company-specific portals. By following naming conventions for tables and columns, consistency in object names will be achieved, making them extra relatable to enterprise terminology and acronyms. Utilizing generative AI fashions on Amazon Bedrock, you’ll be able to improve desk and column descriptions by feeding the fashions with enterprise terminology and acronym definitions together with the database schema objects. This strategy reduces the effort and time required to generate detailed descriptions. The just lately launched metadata characteristic in Amazon DataZone, AI suggestions for descriptions in Amazon DataZone, is alongside these ideas. After you generate the descriptions, you’ll be able to replace the column descriptions utilizing any of the next choices.
    • From the AWS Glue catalog UI
    • Utilizing the AWS Glue SDK just like Step 3a : Create employee_dtls Glue desk for querying from Athena within the 0_create_tables_with_metadata.ipynb Jupyter Pocket book
    • Add the COMMENTS within the DDL script of the desk.

      CREATE EXTERNAL TABLE <table_name> 
      ( column1 string COMMENT '<column_description>' ) 
      PARTITIONED BY ( column2 string COMMENT '<column_description>' )

• For AWS Glue tables cataloged from different databases:
  • You’ll be able to add desk and column descriptions from the supply databases utilizing the crawler in AWS Glue.
  • You’ll be able to configure the EnableAdditionalMetadata Crawler possibility to crawl metadata corresponding to feedback and uncooked information varieties from the underlying information sources. The AWS Glue crawler will then populate the extra metadata in AWS Glue Information Catalog. This gives a option to doc your tables and columns instantly from the metadata outlined within the underlying database.
• Improve the metadata with information profiling: As demonstrated within the earlier part, offering the checklist of values within the worker class column and their which means helped in producing the SQL question with extra correct filter situations. We are able to present such a listing of values or information traits within the column descriptions with the assistance of knowledge profiling. Information profiling is the method of analyzing and understanding the information and its traits as distinct values. Through the use of information profiling insights, we are able to improve column descriptions.
• Improve the metadata with particulars of partitions and a variety of partition values: As demonstrated within the earlier part, offering the checklist of partition values and their which means within the partition column description helped in producing the SQL with extra correct filter situations. For checklist partitions, we are able to add the checklist of the partition values and their meanings to the partition column description. For vary partitions, we are able to add extra context on the grain of the values like each day, month-to-month, and a particular vary of values to the column description.

Enriching the immediate

You’ll be able to improve the prompts with question optimization guidelines like partition pruning. Within the athena_sql_generating_instructions, outlined as a part of the 1_text-to-sql-for-athena.ipynb Jupyter Pocket book, we added an instruction “For tables with partitions, embody the filters on the related partition columns”. This instruction guides the mannequin on easy methods to deal with partition pruning. Within the instance, we noticed that the mannequin added the related partition filter on the region_id partition column. These partition filters will velocity up the SQL question execution and is likely one of the prime question optimization strategies. You’ll be able to add extra such question optimization guidelines to the directions. You’ll be able to improve these directions with related SQL examples.

Cleanup

To scrub up the assets, begin by cleansing up the S3 bucket that was created by the CloudFormation stack. Then delete the CloudFormation stack utilizing the next steps.

• Within the AWS Administration Console, select the identify of the at the moment displayed Area and alter it to US West (Oregon).
• Navigate to AWS CloudFormation.
• Select Stacks.
• Choose texttosqlmetadata
• Select Delete.

Conclusion

The instance introduced within the submit highlights the significance of enriched metadata in producing correct SQL question utilizing the text-to-SQL capabilities of  Anthropic’s Claude mannequin on Amazon Bedrock and discusses a number of methods to complement the metadata. Amazon Bedrock is on the middle of this text-to-SQL technology. Amazon Bedrock might help you construct numerous generative AI functions together with the metadata technology use case talked about within the earlier part. To get began with Amazon Bedrock, we suggest following the short begin within the GitHub repo and familiarizing your self with constructing generative AI functions. After getting acquainted with generative AI functions, see the GitHub Textual content-to-SQL workshop to study extra text-to-SQL strategies. See Construct a strong Textual content-to-SQL resolution and Greatest practices for Textual content-to-SQL for the really useful structure and finest practices to comply with whereas implementing text-to-SQL technology.

Concerning the creator

Naidu Rongali is a Massive Information and ML engineer at Amazon. He designs and develops information processing options for information intensive analytical techniques supporting Amazon retail enterprise. He has been engaged on integrating generative AI capabilities into the information lake and information warehouse techniques utilizing Amazon Bedrock AI fashions. Naidu has a PG diploma in Utilized Statistics from the Indian Statistical Institute, Calcutta and BTech in Electrical and Electronics from NIT, Warangal. Exterior of his work, Naidu practices yoga and goes trekking typically.