t-sql 1.1.0__tar.gz → 1.2.1__tar.gz

{t_sql-1.1.0 → t_sql-1.2.1}/.github/workflows/test.yml

@@ -13,6 +13,21 @@ jobs:
       matrix:
         python-version: ["3.14"]
 
+    services:
+      postgres:
+        image: postgres:18
+        env:
+          POSTGRES_PASSWORD: password
+          POSTGRES_USER: postgres
+          POSTGRES_DB: postgres
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
     steps:
     - uses: actions/checkout@v4
 
@@ -28,4 +43,6 @@ jobs:
       run: uv sync
 
     - name: Run tests
+      env:
+        DATABASE_URL: postgresql://postgres:password@localhost:5432/postgres
       run: uv run pytest -v

t_sql-1.2.1/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

t_sql-1.2.1/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,24 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+    <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ourVersions">
+        <value>
+          <list size="3">
+            <item index="0" class="java.lang.String" itemvalue="3.11" />
+            <item index="1" class="java.lang.String" itemvalue="3.12" />
+            <item index="2" class="java.lang.String" itemvalue="3.13" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="base64.binascii" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

t_sql-1.2.1/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

t_sql-1.2.1/.idea/misc.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="uv (tsql)" />
+  </component>
+  <component name="KubernetesApiPersistence">{}</component>
+  <component name="KubernetesApiProvider"><![CDATA[{
+  "isMigrated": true
+}]]></component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="uv (tsql)" project-jdk-type="Python SDK" />
+</project>

t_sql-1.2.1/.idea/tsql.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module version="4">
+  <component name="PyDocumentationSettings">
+    <option name="format" value="PLAIN" />
+    <option name="myDocStringFormat" value="Plain" />
+  </component>
+  <component name="TestRunnerService">
+    <option name="PROJECT_TEST_RUNNER" value="py.test" />
+  </component>
+</module>

t_sql-1.2.1/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

t_sql-1.2.1/.idea/workspace.xml

@@ -0,0 +1,118 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="059146b3-62bd-4ad4-890d-4356cf237b89" name="Changes" comment="">
+      <change beforePath="$PROJECT_DIR$/pyproject.toml" beforeDir="false" afterPath="$PROJECT_DIR$/pyproject.toml" afterDir="false" />
+    </list>
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="GitHubPullRequestSearchHistory">{
+  &quot;lastFilter&quot;: {
+    &quot;state&quot;: &quot;OPEN&quot;,
+    &quot;assignee&quot;: &quot;nhumrich&quot;
+  }
+}</component>
+  <component name="GithubPullRequestsUISettings">{
+  &quot;selectedUrlAndAccountId&quot;: {
+    &quot;url&quot;: &quot;git@github.com:nhumrich/tsql.git&quot;,
+    &quot;accountId&quot;: &quot;f308fc0d-c429-47fb-8e52-74bdc95408d8&quot;
+  }
+}</component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 2
+}</component>
+  <component name="ProjectId" id="33DagtaPqCq8RWQhigWGQcgOtLh" />
+  <component name="ProjectViewState">
+    <option name="compactDirectories" value="true" />
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;ModuleVcsDetector.initialDetectionPerformed&quot;: &quot;true&quot;,
+    &quot;Python tests.pytest in test_sqlalchemy_integration.py.executor&quot;: &quot;Debug&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.TerminalTabsStorage.copyFrom.TerminalArrangementManager.252&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.git.unshallow&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;main&quot;,
+    &quot;junie.onboarding.icon.badge.shown&quot;: &quot;true&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/home/nhumrich/personal/tsql&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;to.speed.mode.migration.done&quot;: &quot;true&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  }
+}</component>
+  <component name="RunManager">
+    <configuration name="pytest in test_sqlalchemy_integration.py" type="tests" factoryName="py.test" temporary="true" nameIsGenerated="true">
+      <module name="tsql" />
+      <option name="ENV_FILES" value="" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="true" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+      <option name="_new_keywords" value="&quot;&quot;" />
+      <option name="_new_parameters" value="&quot;&quot;" />
+      <option name="_new_additionalArguments" value="&quot;&quot;" />
+      <option name="_new_target" value="&quot;$PROJECT_DIR$/tests/test_sqlalchemy_integration.py&quot;" />
+      <option name="_new_targetType" value="&quot;PATH&quot;" />
+      <method v="2" />
+    </configuration>
+    <recent_temporary>
+      <list>
+        <item itemvalue="Python tests.pytest in test_sqlalchemy_integration.py" />
+      </list>
+    </recent_temporary>
+  </component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-js-predefined-d6986cc7102b-3aa1da707db6-JavaScript-PY-252.26830.99" />
+        <option value="bundled-python-sdk-164cda30dcd9-0af03a5fa574-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-252.26830.99" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="059146b3-62bd-4ad4-890d-4356cf237b89" name="Changes" comment="" />
+      <created>1758854212149</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1758854212149</updated>
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+  <component name="Vcs.Log.Tabs.Properties">
+    <option name="TAB_STATES">
+      <map>
+        <entry key="MAIN">
+          <value>
+            <State />
+          </value>
+        </entry>
+      </map>
+    </option>
+  </component>
+  <component name="com.intellij.coverage.CoverageDataManagerImpl">
+    <SUITE FILE_PATH="coverage/tsql$pytest_in_test_sqlalchemy_integration_py.coverage" NAME="pytest in test_sqlalchemy_integration.py Coverage Results" MODIFIED="1760138305802" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+  </component>
+</project>

{t_sql-1.1.0 → t_sql-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 1.1.0
+Version: 1.2.1
 Summary: Safe SQL. SQL queries for python t-strings (PEP 750)
 Project-URL: Homepage, https://github.com/nhumrich/tsql
 License-File: LICENSE
@@ -154,11 +154,29 @@ values = {'id': 'abc123', 'name': 'bob', 'email': 'bob@example.com'}
 tsql.insert(table, values)
 # INSERT INTO users (id, name, email) VALUES ('abc123', 'bob', 'bob@example.com')
 
+# insert with ignore_conflict
+tsql.insert(table, values, ignore_conflict=True)
+# INSERT INTO users (id, name, email) VALUES ('abc123', 'bob', 'bob@example.com') ON CONFLICT DO NOTHING RETURNING *
+
+# upsert (insert or update on conflict)
+values = {'id': 'abc123', 'name': 'joe', 'email': 'joe@example.com'}
+tsql.upsert(table, values, conflict_on='id')
+# INSERT INTO users (id, name, email) VALUES ('abc123', 'joe', 'joe@example.com')
+# ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, email = EXCLUDED.email RETURNING *
+
+# upsert with multiple conflict columns
+tsql.upsert(table, values, conflict_on=['email', 'name'])
+# ON CONFLICT (email, name) DO UPDATE SET ...
+
 # update values on a single row
 table = 'users'
 values = {'name': 'joe', 'email': 'joe@example.com'}
 tsql.update(table, values, id='abc123')
-# UPDATE users SET name='joe', email='joe@example.com' WHERE id='abc123'
+# UPDATE users SET name='joe', email='joe@example.com' WHERE id='abc123' RETURNING *
+
+# delete a single row
+tsql.delete(table, id='abc123')
+# DELETE FROM users WHERE id = 'abc123'
 ```
 
 # Query Builder
@@ -251,6 +269,54 @@ query = (Posts.select(Posts.title, Users.username)
          .limit(20))
 ```
 
+## Write Operations
+
+The query builder supports INSERT, UPDATE, UPSERT, and DELETE operations:
+
+```python
+# INSERT
+values = {'id': 'abc123', 'username': 'john', 'email': 'john@example.com'}
+query = Users.insert(values)
+sql, params = query.render()
+# INSERT INTO users (id, username, email) VALUES (?, ?, ?) RETURNING *
+
+# INSERT with conflict handling (ignore)
+query = Users.insert(values, ignore_conflict=True)
+sql, params = query.render()
+# INSERT INTO users (id, username, email) VALUES (?, ?, ?) ON CONFLICT DO NOTHING RETURNING *
+
+# UPSERT (INSERT ... ON CONFLICT DO UPDATE)
+values = {'id': 'abc123', 'username': 'john_updated', 'email': 'john@example.com'}
+query = Users.upsert(values, conflict_on='id')
+sql, params = query.render()
+# INSERT INTO users (id, username, email) VALUES (?, ?, ?)
+# ON CONFLICT (id) DO UPDATE SET username=EXCLUDED.username, email=EXCLUDED.email RETURNING *
+
+# UPSERT with multiple conflict columns
+query = Users.upsert(values, conflict_on=['email', 'username'])
+# Can also use Column objects: conflict_on=Users.id or conflict_on=[Users.email, Users.username]
+
+# UPDATE with WHERE conditions
+query = Users.update({'email': 'newemail@example.com'}).where(Users.id == 'abc123')
+sql, params = query.render()
+# UPDATE users SET email=? WHERE users.id = ? RETURNING *
+
+# UPDATE with multiple conditions
+query = (Users.update({'email': 'newemail@example.com'})
+         .where(Users.id == 'abc123')
+         .where(Users.username == 'john'))
+
+# DELETE with WHERE conditions
+query = Users.delete().where(Users.id == 'abc123')
+sql, params = query.render()
+# DELETE FROM users WHERE users.id = ? RETURNING *
+
+# DELETE with multiple conditions
+query = Users.delete().where(Users.id > 100).where(Users.email == None)
+```
+
+All write operations return `RETURNING *` by default to retrieve the affected rows.
+
 ## Advanced Mixed Query (Query Builder + T-Strings)
 
 You can combine the query builder's structured approach with raw t-string conditions for complex logic:

{t_sql-1.1.0 → t_sql-1.2.1}/README.md

@@ -143,11 +143,29 @@ values = {'id': 'abc123', 'name': 'bob', 'email': 'bob@example.com'}
 tsql.insert(table, values)
 # INSERT INTO users (id, name, email) VALUES ('abc123', 'bob', 'bob@example.com')
 
+# insert with ignore_conflict
+tsql.insert(table, values, ignore_conflict=True)
+# INSERT INTO users (id, name, email) VALUES ('abc123', 'bob', 'bob@example.com') ON CONFLICT DO NOTHING RETURNING *
+
+# upsert (insert or update on conflict)
+values = {'id': 'abc123', 'name': 'joe', 'email': 'joe@example.com'}
+tsql.upsert(table, values, conflict_on='id')
+# INSERT INTO users (id, name, email) VALUES ('abc123', 'joe', 'joe@example.com')
+# ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, email = EXCLUDED.email RETURNING *
+
+# upsert with multiple conflict columns
+tsql.upsert(table, values, conflict_on=['email', 'name'])
+# ON CONFLICT (email, name) DO UPDATE SET ...
+
 # update values on a single row
 table = 'users'
 values = {'name': 'joe', 'email': 'joe@example.com'}
 tsql.update(table, values, id='abc123')
-# UPDATE users SET name='joe', email='joe@example.com' WHERE id='abc123'
+# UPDATE users SET name='joe', email='joe@example.com' WHERE id='abc123' RETURNING *
+
+# delete a single row
+tsql.delete(table, id='abc123')
+# DELETE FROM users WHERE id = 'abc123'
 ```
 
 # Query Builder
@@ -240,6 +258,54 @@ query = (Posts.select(Posts.title, Users.username)
          .limit(20))
 ```
 
+## Write Operations
+
+The query builder supports INSERT, UPDATE, UPSERT, and DELETE operations:
+
+```python
+# INSERT
+values = {'id': 'abc123', 'username': 'john', 'email': 'john@example.com'}
+query = Users.insert(values)
+sql, params = query.render()
+# INSERT INTO users (id, username, email) VALUES (?, ?, ?) RETURNING *
+
+# INSERT with conflict handling (ignore)
+query = Users.insert(values, ignore_conflict=True)
+sql, params = query.render()
+# INSERT INTO users (id, username, email) VALUES (?, ?, ?) ON CONFLICT DO NOTHING RETURNING *
+
+# UPSERT (INSERT ... ON CONFLICT DO UPDATE)
+values = {'id': 'abc123', 'username': 'john_updated', 'email': 'john@example.com'}
+query = Users.upsert(values, conflict_on='id')
+sql, params = query.render()
+# INSERT INTO users (id, username, email) VALUES (?, ?, ?)
+# ON CONFLICT (id) DO UPDATE SET username=EXCLUDED.username, email=EXCLUDED.email RETURNING *
+
+# UPSERT with multiple conflict columns
+query = Users.upsert(values, conflict_on=['email', 'username'])
+# Can also use Column objects: conflict_on=Users.id or conflict_on=[Users.email, Users.username]
+
+# UPDATE with WHERE conditions
+query = Users.update({'email': 'newemail@example.com'}).where(Users.id == 'abc123')
+sql, params = query.render()
+# UPDATE users SET email=? WHERE users.id = ? RETURNING *
+
+# UPDATE with multiple conditions
+query = (Users.update({'email': 'newemail@example.com'})
+         .where(Users.id == 'abc123')
+         .where(Users.username == 'john'))
+
+# DELETE with WHERE conditions
+query = Users.delete().where(Users.id == 'abc123')
+sql, params = query.render()
+# DELETE FROM users WHERE users.id = ? RETURNING *
+
+# DELETE with multiple conditions
+query = Users.delete().where(Users.id > 100).where(Users.email == None)
+```
+
+All write operations return `RETURNING *` by default to retrieve the affected rows.
+
 ## Advanced Mixed Query (Query Builder + T-Strings)
 
 You can combine the query builder's structured approach with raw t-string conditions for complex logic:

t_sql-1.2.1/context7.json

@@ -0,0 +1,26 @@
+{
+  "excludeFolders": [
+    "tests",
+    ".github",
+    ".git",
+    "__pycache__",
+    "*.egg-info"
+  ],
+  "excludeFiles": [
+    "LICENSE",
+    "CHANGELOG.md",
+    ".gitignore"
+  ],
+  "rules": [
+    "CRITICAL: This library requires Python 3.14+ due to PEP 750 t-strings. Never suggest it for older Python versions.",
+    "Install with 'uv add t-sql' or 'pip install t-sql'. Use 't-sql[sqlalchemy]' for SQLAlchemy/Alembic integration.",
+    "Always use t-strings (t\"...\") not regular strings (\"\") or f-strings (f\"\"\") for SQL queries. The library is designed so raw strings won't work - this prevents SQL injection by design.",
+    "Use the query builder (@table decorator with typed columns) for complex multi-table joins and structured queries. Use t-string templating for simpler queries or custom SQL logic that the query builder doesn't support.",
+    "The :literal format spec is for dynamic table/column names that cannot be parameterized. It sanitizes against valid SQL identifiers.",
+    "The :unsafe format spec bypasses all safety checks. Only use with hardcoded strings, never with user input.",
+    "The :as_values format spec converts dicts to INSERT VALUES format. The :as_set format spec converts dicts to UPDATE SET format.",
+    "When mixing query builder with t-strings using .where(), t-string conditions are automatically wrapped in parentheses for proper operator precedence.",
+    "The @table decorator returns an instance - use the decorated class directly, don't instantiate it.",
+    "Default parameter style is QMARK (?). Use tsql.styles.NUMERIC_DOLLAR for PostgreSQL ($1, $2), or other styles as needed."
+  ]
+}

{t_sql-1.1.0 → t_sql-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "1.1.0"
+version = "1.2.1"
 description = "Safe SQL. SQL queries for python t-strings (PEP 750)"
 readme = "README.md"
 requires-python = ">=3.14"

{t_sql-1.1.0 → t_sql-1.2.1}/tests/test_asyncpg_integration.py

@@ -1,4 +1,5 @@
 import asyncpg
+import os
 import pytest
 
 import tsql
@@ -6,7 +7,7 @@ import tsql.styles
 
 
 # Test configuration
-DATABASE_URL = "postgresql://postgres:password@localhost:5454/postgres"
+DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:password@localhost:5454/postgres")
 
 
 @pytest.fixture
@@ -233,4 +234,95 @@ async def test_escaped_handles_comment_injection(conn):
     malicious_input = "admin'--"
     query, _ = tsql.render(t"SELECT * FROM test_users WHERE name = {malicious_input}", style=tsql.styles.ESCAPED)
     rows = await conn.fetch(query)
-    assert len(rows) == 0
+    assert len(rows) == 0
+
+
+async def test_upsert_insert_new_row(conn):
+    """Test upsert inserts a new row when no conflict exists"""
+    values = {
+        'id': 1,
+        'name': 'Alice',
+        'age': 30
+    }
+
+    query = tsql.upsert('test_users', values, conflict_on='id')
+    sql, params = query.render(style=tsql.styles.NUMERIC_DOLLAR)
+
+    result = await conn.fetchrow(sql, *params)
+
+    assert result['id'] == 1
+    assert result['name'] == 'Alice'
+    assert result['age'] == 30
+
+
+async def test_upsert_updates_on_conflict(conn):
+    """Test upsert updates existing row on conflict"""
+    # Insert initial row
+    await conn.execute(
+        "INSERT INTO test_users (id, name, age) VALUES ($1, $2, $3)",
+        1, 'Alice', 30
+    )
+
+    # Upsert with same id but different values
+    values = {
+        'id': 1,
+        'name': 'Alice Updated',
+        'age': 31
+    }
+
+    query = tsql.upsert('test_users', values, conflict_on='id')
+    sql, params = query.render(style=tsql.styles.NUMERIC_DOLLAR)
+
+    result = await conn.fetchrow(sql, *params)
+
+    # Should update the existing row
+    assert result['id'] == 1
+    assert result['name'] == 'Alice Updated'
+    assert result['age'] == 31
+
+    # Verify only one row exists
+    count = await conn.fetchval("SELECT COUNT(*) FROM test_users")
+    assert count == 1
+
+
+async def test_upsert_multiple_conflict_columns(conn):
+    """Test upsert with composite unique constraint"""
+    # Create a table with composite unique constraint
+    await conn.execute("""
+        CREATE TABLE IF NOT EXISTS test_emails (
+            user_id INTEGER,
+            email VARCHAR(100),
+            verified BOOLEAN,
+            UNIQUE(user_id, email)
+        )
+    """)
+
+    try:
+        # Insert initial row
+        await conn.execute(
+            "INSERT INTO test_emails (user_id, email, verified) VALUES ($1, $2, $3)",
+            1, 'alice@example.com', False
+        )
+
+        # Upsert with same user_id and email
+        values = {
+            'user_id': 1,
+            'email': 'alice@example.com',
+            'verified': True
+        }
+
+        query = tsql.upsert('test_emails', values, conflict_on=['user_id', 'email'])
+        sql, params = query.render(style=tsql.styles.NUMERIC_DOLLAR)
+
+        result = await conn.fetchrow(sql, *params)
+
+        # Should update verified status
+        assert result['user_id'] == 1
+        assert result['email'] == 'alice@example.com'
+        assert result['verified'] is True
+
+        # Verify only one row exists
+        count = await conn.fetchval("SELECT COUNT(*) FROM test_emails")
+        assert count == 1
+    finally:
+        await conn.execute("DROP TABLE IF EXISTS test_emails")

{t_sql-1.1.0 → t_sql-1.2.1}/tests/test_helper_functions.py

@@ -151,4 +151,79 @@ def test_select_int_id_safe():
 
     # Int should be parameterized
     assert "?" in query
-    assert params == [42]
+    assert params == [42]
+
+
+def test_upsert_single_conflict():
+    """Test upsert with a single conflict column"""
+    values = {
+        'email': 'test@example.com',
+        'name': 'Alice',
+        'age': 30
+    }
+
+    query = tsql.upsert('users', values, conflict_on='email')
+    result = tsql.render(query)
+
+    assert "INSERT INTO users" in result[0]
+    assert "email" in result[0] and "name" in result[0] and "age" in result[0]
+    assert "ON CONFLICT (email)" in result[0]
+    assert "DO UPDATE SET" in result[0]
+    assert "name = EXCLUDED.name" in result[0]
+    assert "age = EXCLUDED.age" in result[0]
+    assert "email = EXCLUDED.email" not in result[0]  # Conflict column shouldn't be in UPDATE
+    assert result[1] == ['test@example.com', 'Alice', 30]
+
+
+def test_upsert_multiple_conflicts():
+    """Test upsert with multiple conflict columns"""
+    values = {
+        'email': 'test@example.com',
+        'username': 'alice',
+        'name': 'Alice Smith'
+    }
+
+    query = tsql.upsert('users', values, conflict_on=['email', 'username'])
+    result = tsql.render(query)
+
+    assert "INSERT INTO users" in result[0]
+    assert "ON CONFLICT (email, username)" in result[0]
+    assert "DO UPDATE SET" in result[0]
+    assert "name = EXCLUDED.name" in result[0]
+    assert "email = EXCLUDED.email" not in result[0]
+    assert "username = EXCLUDED.username" not in result[0]
+
+
+def test_upsert_all_conflict_columns():
+    """Test upsert where all columns are conflict columns (should DO NOTHING)"""
+    values = {
+        'email': 'test@example.com'
+    }
+
+    query = tsql.upsert('users', values, conflict_on='email')
+    result = tsql.render(query)
+
+    assert "INSERT INTO users" in result[0]
+    assert "ON CONFLICT (email)" in result[0]
+    assert "DO NOTHING" in result[0]
+    assert "DO UPDATE" not in result[0]
+
+
+def test_delete():
+    """Test the delete helper function"""
+    query = tsql.delete('users', 123)
+    result = tsql.render(query)
+
+    assert "DELETE FROM users" in result[0]
+    assert "WHERE id = ?" in result[0]
+    assert result[1] == [123]
+
+
+def test_delete_string_id():
+    """Test delete with string ID"""
+    query = tsql.delete('users', 'abc-123')
+    result = tsql.render(query)
+
+    assert "DELETE FROM users" in result[0]
+    assert "WHERE id = ?" in result[0]
+    assert result[1] == ['abc-123']

{t_sql-1.1.0 → t_sql-1.2.1}/tests/test_injection_protection_validation.py

@@ -1,11 +1,12 @@
 import asyncpg
+import os
 import pytest
 
 import tsql
 import tsql.styles
 
 # Test configuration
-DATABASE_URL = "postgresql://postgres:password@localhost:5454/postgres"
+DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:password@localhost:5454/postgres")
 
 
 @pytest.fixture

{t_sql-1.1.0 → t_sql-1.2.1}/tests/test_injections_for_escaped.py

@@ -3,12 +3,13 @@ Proof-of-concept test demonstrating that tsql actually prevents SQL injection at
 against a real PostgreSQL database.
 """
 import asyncpg
+import os
 import pytest
 
 import tsql
 import tsql.styles
 
-DATABASE_URL = "postgresql://postgres:password@localhost:5454/postgres"
+DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://postgres:password@localhost:5454/postgres")
 
 
 @pytest.fixture

{t_sql-1.1.0 → t_sql-1.2.1}/tests/test_query_builder.py

@@ -1,5 +1,5 @@
 import tsql
-from tsql.query_builder import table, Column, Condition
+from tsql.query_builder import table, Column, Condition, UpdateBuilder, DeleteBuilder
 
 
 @table('users')
@@ -388,3 +388,145 @@ def test_where_with_tstring_complex():
     assert 'WHERE users.id > ?' in sql
     assert 'AND (username ILIKE ? OR email ILIKE ?)' in sql
     assert params == [5, 'john', 'jane']
+
+
+def test_table_insert():
+    """Test table.insert() method"""
+    query = Users.insert({'username': 'bob', 'email': 'bob@example.com'})
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'username' in sql and 'email' in sql
+    assert 'VALUES' in sql
+    assert 'RETURNING *' in sql
+    assert params == ['bob', 'bob@example.com']
+
+
+def test_table_insert_ignore_conflict():
+    """Test table.insert() with ignore_conflict"""
+    query = Users.insert({'username': 'bob', 'email': 'bob@example.com'}, ignore_conflict=True)
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT DO NOTHING' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_upsert():
+    """Test table.upsert() method"""
+    query = Users.upsert({'email': 'bob@example.com', 'username': 'bob'}, conflict_on='email')
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT (email)' in sql
+    assert 'DO UPDATE SET' in sql
+    assert 'username = EXCLUDED.username' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_upsert_with_column_object():
+    """Test table.upsert() with Column object"""
+    query = Users.upsert({'email': 'bob@example.com', 'username': 'bob'}, conflict_on=Users.email)
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT (email)' in sql
+    assert 'DO UPDATE SET' in sql
+    assert 'username = EXCLUDED.username' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_upsert_with_multiple_column_objects():
+    """Test table.upsert() with multiple Column objects"""
+    query = Users.upsert(
+        {'email': 'bob@example.com', 'username': 'bob', 'created_at': '2024-01-01'},
+        conflict_on=[Users.email, Users.username]
+    )
+    sql, params = query.render()
+
+    assert 'INSERT INTO users' in sql
+    assert 'ON CONFLICT (email, username)' in sql
+    assert 'DO UPDATE SET' in sql
+    assert 'created_at = EXCLUDED.created_at' in sql
+    assert 'RETURNING *' in sql
+
+
+def test_table_update_with_where():
+    """Test table.update() with WHERE clause"""
+    builder = Users.update({'username': 'bob_updated'}).where(Users.id == 5)
+    assert isinstance(builder, UpdateBuilder)
+
+    sql, params = builder.render()
+
+    assert 'UPDATE users SET' in sql
+    assert 'username = ?' in sql
+    assert 'WHERE users.id = ?' in sql
+    assert 'RETURNING *' in sql
+    assert params == ['bob_updated', 5]
+
+
+def test_table_update_multiple_conditions():
+    """Test table.update() with multiple WHERE conditions"""
+    builder = (Users.update({'username': 'bob_updated', 'email': 'new@example.com'})
+               .where(Users.id > 10)
+               .where(Users.created_at == None))
+
+    sql, params = builder.render()
+
+    assert 'UPDATE users SET' in sql
+    assert 'WHERE users.id > ?' in sql
+    assert 'AND users.created_at IS NULL' in sql
+    assert 'RETURNING *' in sql
+    assert params == ['bob_updated', 'new@example.com', 10]
+
+
+def test_table_delete_with_where():
+    """Test table.delete() with WHERE clause"""
+    builder = Users.delete().where(Users.id == 5)
+    assert isinstance(builder, DeleteBuilder)
+
+    sql, params = builder.render()
+
+    assert 'DELETE FROM users' in sql
+    assert 'WHERE users.id = ?' in sql
+    assert 'RETURNING *' in sql
+    assert params == [5]
+
+
+def test_table_delete_multiple_conditions():
+    """Test table.delete() with multiple WHERE conditions"""
+    builder = (Users.delete()
+               .where(Users.id > 100)
+               .where(Users.email == None))
+
+    sql, params = builder.render()
+
+    assert 'DELETE FROM users' in sql
+    assert 'WHERE users.id > ?' in sql
+    assert 'AND users.email IS NULL' in sql
+    assert 'RETURNING *' in sql
+    assert params == [100]
+
+
+def test_update_with_t_string_where():
+    """Test UpdateBuilder with raw t-string WHERE clause"""
+    min_age = 18
+    builder = Users.update({'username': 'adult'}).where(t"age >= {min_age}")
+
+    sql, params = builder.render()
+
+    assert 'UPDATE users SET' in sql
+    assert 'WHERE (age >= ?)' in sql
+    assert params == ['adult', 18]
+
+
+def test_delete_with_t_string_where():
+    """Test DeleteBuilder with raw t-string WHERE clause"""
+    pattern = '%test%'
+    builder = Users.delete().where(t"email LIKE {pattern}")
+
+    sql, params = builder.render()
+
+    assert 'DELETE FROM users' in sql
+    assert 'WHERE (email LIKE ?)' in sql
+    assert params == ['%test%']

{t_sql-1.1.0 → t_sql-1.2.1}/tsql/__init__.py

@@ -72,7 +72,12 @@ class TSQL:
 
     @classmethod
     def _check_literal(cls, val: str):
-        if not isinstance(val, str) or not val.isidentifier():
+        if not isinstance(val, str):
+            raise ValueError(f"Invalid literal {val}")
+
+        # Allow qualified identifiers (table.column, schema.table.column)
+        parts = val.split('.')
+        if not parts or not all(part.isidentifier() for part in parts):
             raise ValueError(f"Invalid literal {val}")
         return val
 
@@ -239,6 +244,68 @@ def update(table: str, values: dict[str, Any], id: str):
 
     if not isinstance(values, dict):
         raise ValueError("values must be a dictionary")
-    
+
     return TSQL(t"UPDATE {table:literal} SET {values:as_set} WHERE id = {id} RETURNING *")
 
+
+def upsert(table: str, values: dict[str, Any], conflict_on: str | list[str]):
+    """Helper function to build INSERT ... ON CONFLICT DO UPDATE (upsert) queries
+
+    Args:
+        table: Table name
+        values: Dictionary of column names and values to insert
+        conflict_on: Column name(s) that define the conflict constraint
+
+    Returns:
+        TSQL object representing the upsert query
+    """
+    if not isinstance(values, dict):
+        raise TypeError("values must be a dict")
+
+    # Normalize conflict_on to a list
+    conflict_cols = [conflict_on] if isinstance(conflict_on, str) else conflict_on
+
+    # Build the conflict target: ON CONFLICT (col1, col2)
+    conflict_target_parts = ['(']
+    for i, col in enumerate(conflict_cols):
+        if i > 0:
+            conflict_target_parts.append(', ')
+        conflict_target_parts.append(col)
+    conflict_target_parts.append(')')
+
+    # Build the UPDATE SET clause with EXCLUDED.* for non-conflict columns
+    update_cols = {k: v for k, v in values.items() if k not in conflict_cols}
+
+    if not update_cols:
+        # If all columns are conflict columns, just do nothing
+        conflict_clause_parts = [' ON CONFLICT '] + conflict_target_parts + [' DO NOTHING']
+    else:
+        update_set_parts = []
+        for i, key in enumerate(update_cols.keys()):
+            if i > 0:
+                update_set_parts.append(', ')
+            update_set_parts.append(key)
+            update_set_parts.append(' = EXCLUDED.')
+            update_set_parts.append(key)
+
+        conflict_clause_parts = [' ON CONFLICT '] + conflict_target_parts + [' DO UPDATE SET '] + update_set_parts
+
+    # Create the conflict clause TSQL object
+    conflict_tsql = TSQL.__new__(TSQL)
+    conflict_tsql._sql_parts = conflict_clause_parts
+
+    return TSQL(t"INSERT INTO {table:literal} {values:as_values}{conflict_tsql} RETURNING *")
+
+
+def delete(table: str, id: str|int):
+    """Helper function to build DELETE queries for a single row
+
+    Args:
+        table: Table name
+        id: ID value to delete
+
+    Returns:
+        TSQL object representing the DELETE query
+    """
+    return TSQL(t"DELETE FROM {table:literal} WHERE id = {id}")
+

{t_sql-1.1.0 → t_sql-1.2.1}/tsql/query_builder.py

@@ -3,7 +3,7 @@ from string.templatelib import Template
 from functools import wraps
 from datetime import datetime
 
-from tsql import TSQL, t_join
+from tsql import TSQL, t_join, insert as tsql_insert, upsert as tsql_upsert, delete as tsql_delete, as_set
 
 # Optional SQLAlchemy support
 try:
@@ -128,6 +128,104 @@ class Join:
         return t'{join_type:unsafe} JOIN {table_name:literal} ON {condition_tsql}'
 
 
+class UpdateBuilder:
+    """Fluent interface for building UPDATE queries"""
+
+    def __init__(self, base_table: 'Table', values: dict[str, Any]):
+        self.base_table = base_table
+        self.values = values
+        self._conditions: List[Union[Condition, Template]] = []
+
+    def where(self, condition: Union[Condition, Template]) -> 'UpdateBuilder':
+        """Add a WHERE condition (multiple calls are ANDed together)"""
+        self._conditions.append(condition)
+        return self
+
+    def to_tsql(self) -> TSQL:
+        """Build the final TSQL object"""
+        parts: List[Template] = []
+
+        table_name = self.base_table.table_name
+        values_dict = self.values
+        parts.append(t'UPDATE {table_name:literal} SET {values_dict:as_set}')
+
+        if self._conditions:
+            where_parts = []
+            for cond in self._conditions:
+                if isinstance(cond, Template):
+                    where_parts.append(t'({cond})')
+                else:
+                    where_parts.append(cond.to_tsql())
+            combined_where = t_join(t' AND ', where_parts)
+            parts.append(t'WHERE {combined_where}')
+
+        parts.append(t'RETURNING *')
+
+        return TSQL(t_join(t' ', parts))
+
+    def render(self, style=None):
+        """Convenience method to render the query directly"""
+        return self.to_tsql().render(style)
+
+    def __repr__(self) -> str:
+        """Show the rendered SQL query for debugging"""
+        try:
+            query, params = self.to_tsql().render()
+            if params:
+                return f"UpdateBuilder(\n  SQL: {query}\n  Params: {params}\n)"
+            return f"UpdateBuilder({query})"
+        except Exception as e:
+            return f"UpdateBuilder(<error rendering: {e}>)"
+
+
+class DeleteBuilder:
+    """Fluent interface for building DELETE queries"""
+
+    def __init__(self, base_table: 'Table'):
+        self.base_table = base_table
+        self._conditions: List[Union[Condition, Template]] = []
+
+    def where(self, condition: Union[Condition, Template]) -> 'DeleteBuilder':
+        """Add a WHERE condition (multiple calls are ANDed together)"""
+        self._conditions.append(condition)
+        return self
+
+    def to_tsql(self) -> TSQL:
+        """Build the final TSQL object"""
+        parts: List[Template] = []
+
+        table_name = self.base_table.table_name
+        parts.append(t'DELETE FROM {table_name:literal}')
+
+        if self._conditions:
+            where_parts = []
+            for cond in self._conditions:
+                if isinstance(cond, Template):
+                    where_parts.append(t'({cond})')
+                else:
+                    where_parts.append(cond.to_tsql())
+            combined_where = t_join(t' AND ', where_parts)
+            parts.append(t'WHERE {combined_where}')
+
+        parts.append(t'RETURNING *')
+
+        return TSQL(t_join(t' ', parts))
+
+    def render(self, style=None):
+        """Convenience method to render the query directly"""
+        return self.to_tsql().render(style)
+
+    def __repr__(self) -> str:
+        """Show the rendered SQL query for debugging"""
+        try:
+            query, params = self.to_tsql().render()
+            if params:
+                return f"DeleteBuilder(\n  SQL: {query}\n  Params: {params}\n)"
+            return f"DeleteBuilder({query})"
+        except Exception as e:
+            return f"DeleteBuilder(<error rendering: {e}>)"
+
+
 class QueryBuilder:
     """Fluent interface for building SQL queries"""
 
@@ -374,7 +472,60 @@ def table(name: str, *, metadata: Optional[Any] = None, schema: Optional[str] =
                 builder.select(*columns)
             return builder
 
+        def insert(self, values: dict[str, Any], ignore_conflict: bool = False) -> TSQL:
+            """Insert a row into the table
+
+            Args:
+                values: Dictionary of column names and values
+                ignore_conflict: If True, adds ON CONFLICT DO NOTHING
+
+            Returns:
+                TSQL object representing the INSERT query
+            """
+            return tsql_insert(self.table_name, values, ignore_conflict=ignore_conflict)
+
+        def upsert(self, values: dict[str, Any], conflict_on: str | list[str] | Column | list[Column]) -> TSQL:
+            """Upsert (INSERT ... ON CONFLICT DO UPDATE) a row
+
+            Args:
+                values: Dictionary of column names and values
+                conflict_on: Column name(s) or Column object(s) that define the conflict constraint
+
+            Returns:
+                TSQL object representing the UPSERT query
+            """
+            # Convert Column objects to strings
+            if isinstance(conflict_on, Column):
+                conflict_on = conflict_on.column_name
+            elif isinstance(conflict_on, list):
+                conflict_on = [col.column_name if isinstance(col, Column) else col for col in conflict_on]
+
+            return tsql_upsert(self.table_name, values, conflict_on=conflict_on)
+
+        def update(self, values: dict[str, Any]) -> UpdateBuilder:
+            """Start building an UPDATE query
+
+            Args:
+                values: Dictionary of column names and values to update
+
+            Returns:
+                UpdateBuilder for adding WHERE conditions
+            """
+            return UpdateBuilder(self, values)
+
+        def delete(self) -> DeleteBuilder:
+            """Start building a DELETE query
+
+            Returns:
+                DeleteBuilder for adding WHERE conditions
+            """
+            return DeleteBuilder(self)
+
         cls.select = select
+        cls.insert = insert
+        cls.upsert = upsert
+        cls.update = update
+        cls.delete = delete
 
         # Return an instance instead of the class
         return cls()