inserts a value into the result hashmap it should only insert a value if you are working with a non-subquery queries

Inserts a parameter into TsQuery for type definition generation If you pass in the order argument, it will use the manually passed in order It's impor

fetch table's column details from information_schema of each database type # MySQL Notes - TABLE_SCHEMA in MySQL is basically the `database_name`, so

The method process block statement as expression It receives a block statement object from Class expression inserts the sqls into the sqls vector

Internal helper that checks a specific direction: column_expr for column name, placeholder_expr for placeholder

Translates a select item's target table by looking for TableWithJoins If the select item uses table alias, it should find the table name using the ali

Given an expression e.g. WHERE some_column = ? e.g. WHERE some_table.some_column = ? it should receive `?` or `$1` and determine that it is a placeh

Helper: creates a temporary SQLite database with the given schema, then runs sqlx-ts on the given TS content, and returns the generated types.

The function takes in an expression such as Example 1: given `SELECT id FROM items` expression is `id`

Runs the prepare statement on the input SQL. Validates the query is right by directly connecting to the configured database. It also processes ts inte

Extract expression from a function argument

handle an expression from where clauses (or it can be from anywhere) pick up any expression from left and right that goes some_field = ? some_table.so

Process key-value pairs from JSON build object arguments

Translates a wildcard expression of a SQL statement @example SELECT * FROM items and it appends result into the hashmap for type generation

clears the target single TS file if it exists

Extract annotations from SQL content and return cleaned query Supports @name and @db annotations

Extract key name from a function argument (should be a string literal)

Extract SQL queries from raw SQL file content Supports multiple queries separated by semicolons and annotations

The method is to format SQL params extracted via translate methods It can work for SELECT, INSERT, DELETE and UPDATE queries

Format a field name for TypeScript object literal, quoting if necessary

Generate a default query name from file path and index

By passing in a SQL query, for example e.g. -- @db: postgres SELECT * FROM some_table; The method figures out the connection name to connect in order

Get the database type for this connection

This is to follow the spec of connection string for MySQL https://dev.mysql.com/doc/connector-j/8.1/en/connector-j-reference-jdbc-url-format.html

you would normally pass in any var declarator such as const sql = sql`SELECT * FROM xxx;`

Returns the file path for a SQLite database connection. If DB_URL is provided, it's used directly. Otherwise DB_NAME is used as the file path.

The method grabs the name of the variable if it exists

Check if the current log level is greater than or equal to the other log level

Handle JSON aggregation functions (jsonb_agg, json_agg, etc.)

Handle JSON build functions (jsonb_build_object, json_build_object, etc.)

Infer the TypeScript type from an SQL expression

This is used to insert value params required for INSERT statements For example if you are given e.g. INSERT INTO table (id, name, address) VALUES (?,

Check if a block contains only comments and whitespace

Check if a string is a valid TypeScript identifier