ydb-sqlalchemy 0.1.9__py2.py3-none-any.whl → 0.1.11__py2.py3-none-any.whl

test/test_suite.py

@@ -1,4 +1,6 @@
 import ctypes
+import datetime
+import decimal
 
 import pytest
 import sqlalchemy as sa
@@ -266,7 +268,7 @@ class IntegerTest(_IntegerTest):
         pass
 
 
-@pytest.mark.skip("TODO: fix & skip those tests - add Double/Decimal support. see #12")
+@pytest.mark.skip("Use YdbDecimalTest for Decimal type testing")
 class NumericTest(_NumericTest):
     # SqlAlchemy maybe eat Decimal and throw Double
     pass
@@ -423,6 +425,16 @@ class DateTest(_DateTest):
     run_dispose_bind = "once"
 
 
+class Date32Test(_DateTest):
+    run_dispose_bind = "once"
+    datatype = ydb_sa_types.YqlDate32
+    data = datetime.date(1969, 1, 1)
+
+    @pytest.mark.skip("Default binding for DATE is not compatible with Date32")
+    def test_select_direct(self, connection):
+        pass
+
+
 class DateTimeMicrosecondsTest(_DateTimeMicrosecondsTest):
     run_dispose_bind = "once"
 
@@ -431,10 +443,30 @@ class DateTimeTest(_DateTimeTest):
     run_dispose_bind = "once"
 
 
+class DateTime64Test(_DateTimeTest):
+    datatype = ydb_sa_types.YqlDateTime64
+    data = datetime.datetime(1969, 10, 15, 12, 57, 18)
+    run_dispose_bind = "once"
+
+    @pytest.mark.skip("Default binding for DATETIME is not compatible with DateTime64")
+    def test_select_direct(self, connection):
+        pass
+
+
 class TimestampMicrosecondsTest(_TimestampMicrosecondsTest):
     run_dispose_bind = "once"
 
 
+class Timestamp64MicrosecondsTest(_TimestampMicrosecondsTest):
+    run_dispose_bind = "once"
+    datatype = ydb_sa_types.YqlTimestamp64
+    data = datetime.datetime(1969, 10, 15, 12, 57, 18, 396)
+
+    @pytest.mark.skip("Default binding for TIMESTAMP is not compatible with Timestamp64")
+    def test_select_direct(self, connection):
+        pass
+
+
 @pytest.mark.skip("unsupported Time data type")
 class TimeTest(_TimeTest):
     pass
@@ -596,3 +628,256 @@ class RowFetchTest(_RowFetchTest):
     @pytest.mark.skip("scalar subquery unsupported")
     def test_row_w_scalar_select(self, connection):
         pass
+
+
+class DecimalTest(fixtures.TablesTest):
+    """Tests for YDB Decimal type using standard sa.DECIMAL"""
+
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "decimal_test",
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("decimal_default", sa.DECIMAL),  # Default: precision=22, scale=9
+            Column("decimal_custom", sa.DECIMAL(precision=10, scale=2)),
+            Column("decimal_as_float", sa.DECIMAL(asdecimal=False)),  # Should behave like Float
+        )
+
+    def test_decimal_basic_operations(self, connection):
+        """Test basic insert and select operations with Decimal"""
+
+        table = self.tables.decimal_test
+
+        test_values = [
+            decimal.Decimal("1"),
+            decimal.Decimal("2"),
+            decimal.Decimal("3"),
+        ]
+
+        # Insert test values
+        for i, val in enumerate(test_values):
+            connection.execute(table.insert().values(id=i + 1, decimal_default=val))
+
+        # Select and verify
+        results = connection.execute(select(table.c.decimal_default).order_by(table.c.id)).fetchall()
+
+        for i, (result,) in enumerate(results):
+            expected = test_values[i]
+            assert isinstance(result, decimal.Decimal)
+            assert result == expected
+
+    def test_decimal_with_precision_scale(self, connection):
+        """Test Decimal with specific precision and scale"""
+
+        table = self.tables.decimal_test
+
+        # Test value that fits precision(10, 2)
+        test_value = decimal.Decimal("12345678.99")
+
+        connection.execute(table.insert().values(id=100, decimal_custom=test_value))
+
+        result = connection.scalar(select(table.c.decimal_custom).where(table.c.id == 100))
+
+        assert isinstance(result, decimal.Decimal)
+        assert result == test_value
+
+    def test_decimal_literal_rendering(self, connection):
+        """Test literal rendering of Decimal values"""
+        from sqlalchemy import literal
+
+        table = self.tables.decimal_test
+
+        # Test literal in INSERT
+        test_value = decimal.Decimal("999.99")
+
+        connection.execute(table.insert().values(id=300, decimal_default=literal(test_value, sa.DECIMAL())))
+
+        result = connection.scalar(select(table.c.decimal_default).where(table.c.id == 300))
+
+        assert isinstance(result, decimal.Decimal)
+        assert result == test_value
+
+    def test_decimal_overflow(self, connection):
+        """Test behavior when precision is exceeded"""
+
+        table = self.tables.decimal_test
+
+        # Try to insert value that exceeds precision=10, scale=2
+        overflow_value = decimal.Decimal("99999.99999")
+
+        with pytest.raises(Exception):  # Should raise some kind of database error
+            connection.execute(table.insert().values(id=500, decimal_custom=overflow_value))
+            connection.commit()
+
+    def test_decimal_asdecimal_false(self, connection):
+        """Test DECIMAL with asdecimal=False (should return float)"""
+
+        table = self.tables.decimal_test
+
+        test_value = decimal.Decimal("123.45")
+
+        connection.execute(table.insert().values(id=600, decimal_as_float=test_value))
+
+        result = connection.scalar(select(table.c.decimal_as_float).where(table.c.id == 600))
+
+        assert isinstance(result, float), f"Expected float, got {type(result)}"
+        assert abs(result - 123.45) < 0.01
+
+    def test_decimal_arithmetic(self, connection):
+        """Test arithmetic operations with Decimal columns"""
+
+        table = self.tables.decimal_test
+
+        val1 = decimal.Decimal("100.50")
+        val2 = decimal.Decimal("25.25")
+
+        connection.execute(table.insert().values(id=900, decimal_default=val1))
+        connection.execute(table.insert().values(id=901, decimal_default=val2))
+
+        # Test various arithmetic operations
+        addition_result = connection.scalar(
+            select(table.c.decimal_default + decimal.Decimal("10.00")).where(table.c.id == 900)
+        )
+
+        subtraction_result = connection.scalar(
+            select(table.c.decimal_default - decimal.Decimal("5.25")).where(table.c.id == 900)
+        )
+
+        multiplication_result = connection.scalar(
+            select(table.c.decimal_default * decimal.Decimal("2.0")).where(table.c.id == 901)
+        )
+
+        division_result = connection.scalar(
+            select(table.c.decimal_default / decimal.Decimal("2.0")).where(table.c.id == 901)
+        )
+
+        # Verify results
+        assert abs(addition_result - decimal.Decimal("110.50")) < decimal.Decimal("0.01")
+        assert abs(subtraction_result - decimal.Decimal("95.25")) < decimal.Decimal("0.01")
+        assert abs(multiplication_result - decimal.Decimal("50.50")) < decimal.Decimal("0.01")
+        assert abs(division_result - decimal.Decimal("12.625")) < decimal.Decimal("0.01")
+
+    def test_decimal_comparison_operations(self, connection):
+        """Test comparison operations with Decimal columns"""
+
+        table = self.tables.decimal_test
+
+        values = [
+            decimal.Decimal("10.50"),
+            decimal.Decimal("20.75"),
+            decimal.Decimal("15.25"),
+        ]
+
+        for i, val in enumerate(values):
+            connection.execute(table.insert().values(id=1000 + i, decimal_default=val))
+
+        # Test various comparisons
+        greater_than = connection.execute(
+            select(table.c.id).where(table.c.decimal_default > decimal.Decimal("15.00")).order_by(table.c.id)
+        ).fetchall()
+
+        less_than = connection.execute(
+            select(table.c.id).where(table.c.decimal_default < decimal.Decimal("15.00")).order_by(table.c.id)
+        ).fetchall()
+
+        equal_to = connection.execute(
+            select(table.c.id).where(table.c.decimal_default == decimal.Decimal("15.25"))
+        ).fetchall()
+
+        between_values = connection.execute(
+            select(table.c.id)
+            .where(table.c.decimal_default.between(decimal.Decimal("15.00"), decimal.Decimal("21.00")))
+            .order_by(table.c.id)
+        ).fetchall()
+
+        # Verify results
+        assert len(greater_than) == 2  # 20.75 and 15.25
+        assert len(less_than) == 1  # 10.50
+        assert len(equal_to) == 1  # 15.25
+        assert len(between_values) == 2  # 20.75 and 15.25
+
+    def test_decimal_null_handling(self, connection):
+        """Test NULL handling with Decimal columns"""
+
+        table = self.tables.decimal_test
+
+        # Insert NULL value
+        connection.execute(table.insert().values(id=1100, decimal_default=None))
+
+        # Insert non-NULL value for comparison
+        connection.execute(table.insert().values(id=1101, decimal_default=decimal.Decimal("42.42")))
+
+        # Test NULL retrieval
+        null_result = connection.scalar(select(table.c.decimal_default).where(table.c.id == 1100))
+
+        non_null_result = connection.scalar(select(table.c.decimal_default).where(table.c.id == 1101))
+
+        assert null_result is None
+        assert non_null_result == decimal.Decimal("42.42")
+
+        # Test IS NULL / IS NOT NULL
+        null_count = connection.scalar(select(func.count()).where(table.c.decimal_default.is_(None)))
+
+        not_null_count = connection.scalar(select(func.count()).where(table.c.decimal_default.isnot(None)))
+
+        # Should have at least 1 NULL and several non-NULL values from other tests
+        assert null_count >= 1
+        assert not_null_count >= 1
+
+    def test_decimal_input_type_conversion(self, connection):
+        """Test that bind_processor handles different input types correctly (float, string, int, Decimal)"""
+
+        table = self.tables.decimal_test
+
+        # Test different input types that should all be converted to Decimal
+        test_cases = [
+            (1400, 123.45, "float input"),  # float
+            (1401, "456.78", "string input"),  # string
+            (1402, decimal.Decimal("789.12"), "decimal input"),  # already Decimal
+            (1403, 100, "int input"),  # int
+        ]
+
+        for test_id, input_value, description in test_cases:
+            connection.execute(table.insert().values(id=test_id, decimal_default=input_value))
+
+            result = connection.scalar(select(table.c.decimal_default).where(table.c.id == test_id))
+
+            # All should be returned as Decimal
+            assert isinstance(result, decimal.Decimal), f"Failed for {description}: got {type(result)}"
+
+            # Verify the value is approximately correct
+            expected = decimal.Decimal(str(input_value))
+            error_str = f"Failed for {description}: expected {expected}, got {result}"
+            assert abs(result - expected) < decimal.Decimal("0.01"), error_str
+
+    def test_decimal_asdecimal_comparison(self, connection):
+        """Test comparison between asdecimal=True and asdecimal=False behavior"""
+
+        table = self.tables.decimal_test
+
+        test_value = decimal.Decimal("999.123")
+
+        # Insert same value into both columns
+        connection.execute(
+            table.insert().values(
+                id=1500,
+                decimal_default=test_value,  # asdecimal=True (default)
+                decimal_as_float=test_value,  # asdecimal=False
+            )
+        )
+
+        # Get results from both columns
+        result_as_decimal = connection.scalar(select(table.c.decimal_default).where(table.c.id == 1500))
+        result_as_float = connection.scalar(select(table.c.decimal_as_float).where(table.c.id == 1500))
+
+        # Check types are different
+        assert isinstance(result_as_decimal, decimal.Decimal), f"Expected Decimal, got {type(result_as_decimal)}"
+        assert isinstance(result_as_float, float), f"Expected float, got {type(result_as_float)}"
+
+        # Check values are approximately equal
+        assert abs(result_as_decimal - test_value) < decimal.Decimal("0.001")
+        assert abs(result_as_float - float(test_value)) < 0.001
+
+        # Check that converting between them gives same value
+        assert abs(float(result_as_decimal) - result_as_float) < 0.001

ydb_sqlalchemy/_version.py

@@ -1 +1 @@
-VERSION = "0.1.9"
+VERSION = "0.1.11"

ydb_sqlalchemy/sqlalchemy/__init__.py

@@ -61,6 +61,9 @@ COLUMN_TYPES = {
     ydb.DecimalType: sa.DECIMAL,
     ydb.PrimitiveType.Yson: sa.TEXT,
     ydb.PrimitiveType.Date: sa.DATE,
+    ydb.PrimitiveType.Date32: sa.DATE,
+    ydb.PrimitiveType.Timestamp64: sa.TIMESTAMP,
+    ydb.PrimitiveType.Datetime64: sa.DATETIME,
     ydb.PrimitiveType.Datetime: sa.DATETIME,
     ydb.PrimitiveType.Timestamp: sa.TIMESTAMP,
     ydb.PrimitiveType.Interval: sa.INTEGER,
@@ -136,9 +139,11 @@ class YqlDialect(StrCompileDialect):
     colspecs = {
         sa.types.JSON: types.YqlJSON,
         sa.types.JSON.JSONPathType: types.YqlJSON.YqlJSONPathType,
+        sa.types.Date: types.YqlDate,
         sa.types.DateTime: types.YqlTimestamp,  # Because YDB's DateTime doesn't store microseconds
         sa.types.DATETIME: types.YqlDateTime,
         sa.types.TIMESTAMP: types.YqlTimestamp,
+        sa.types.DECIMAL: types.Decimal,
     }
 
     connection_characteristics = util.immutabledict(

ydb_sqlalchemy/sqlalchemy/compiler/base.py

@@ -113,9 +113,13 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
         return "Int64"
 
     def visit_NUMERIC(self, type_: sa.Numeric, **kw):
-        """Only Decimal(22,9) is supported for table columns"""
         return f"Decimal({type_.precision}, {type_.scale})"
 
+    def visit_DECIMAL(self, type_: sa.DECIMAL, **kw):
+        precision = getattr(type_, "precision", None) or 22
+        scale = getattr(type_, "scale", None) or 9
+        return f"Decimal({precision}, {scale})"
+
     def visit_BINARY(self, type_: sa.BINARY, **kw):
         return "String"
 
@@ -131,6 +135,15 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
     def visit_TIMESTAMP(self, type_: sa.TIMESTAMP, **kw):
         return "Timestamp"
 
+    def visit_date32(self, type_: types.YqlDate32, **kw):
+        return "Date32"
+
+    def visit_timestamp64(self, type_: types.YqlTimestamp64, **kw):
+        return "Timestamp64"
+
+    def visit_datetime64(self, type_: types.YqlDateTime64, **kw):
+        return "DateTime64"
+
     def visit_list_type(self, type_: types.ListType, **kw):
         inner = self.process(type_.item_type, **kw)
         return f"List<{inner}>"
@@ -189,6 +202,12 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
         elif isinstance(type_, types.YqlJSON.YqlJSONPathType):
             ydb_type = ydb.PrimitiveType.Utf8
         # Json
+        elif isinstance(type_, types.YqlDate32):
+            ydb_type = ydb.PrimitiveType.Date32
+        elif isinstance(type_, types.YqlTimestamp64):
+            ydb_type = ydb.PrimitiveType.Timestamp64
+        elif isinstance(type_, types.YqlDateTime64):
+            ydb_type = ydb.PrimitiveType.Datetime64
         elif isinstance(type_, sa.DATETIME):
             ydb_type = ydb.PrimitiveType.Datetime
         elif isinstance(type_, sa.TIMESTAMP):
@@ -204,7 +223,9 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
         elif isinstance(type_, sa.Boolean):
             ydb_type = ydb.PrimitiveType.Bool
         elif isinstance(type_, sa.Numeric):
-            ydb_type = ydb.DecimalType(type_.precision, type_.scale)
+            precision = getattr(type_, "precision", None) or 22
+            scale = getattr(type_, "scale", None) or 9
+            ydb_type = ydb.DecimalType(precision, scale)
         elif isinstance(type_, (types.ListType, sa.ARRAY)):
             ydb_type = ydb.ListType(self.get_ydb_type(type_.item_type, is_optional=False))
         elif isinstance(type_, types.StructType):

ydb_sqlalchemy/sqlalchemy/datetime_types.py

@@ -4,6 +4,16 @@ from typing import Optional
 from sqlalchemy import types as sqltypes
 
 
+class YqlDate(sqltypes.Date):
+    def literal_processor(self, dialect):
+        parent = super().literal_processor(dialect)
+
+        def process(value):
+            return f"Date({parent(value)})"
+
+        return process
+
+
 class YqlTimestamp(sqltypes.TIMESTAMP):
     def result_processor(self, dialect, coltype):
         def process(value: Optional[datetime.datetime]) -> Optional[datetime.datetime]:
@@ -26,3 +36,39 @@ class YqlDateTime(YqlTimestamp, sqltypes.DATETIME):
             return int(value.timestamp())
 
         return process
+
+
+class YqlDate32(YqlDate):
+    __visit_name__ = "date32"
+
+    def literal_processor(self, dialect):
+        parent = super().literal_processor(dialect)
+
+        def process(value):
+            return f"Date32({parent(value)})"
+
+        return process
+
+
+class YqlTimestamp64(YqlTimestamp):
+    __visit_name__ = "timestamp64"
+
+    def literal_processor(self, dialect):
+        parent = super().literal_processor(dialect)
+
+        def process(value):
+            return f"Timestamp64({parent(value)})"
+
+        return process
+
+
+class YqlDateTime64(YqlDateTime):
+    __visit_name__ = "datetime64"
+
+    def literal_processor(self, dialect):
+        parent = super().literal_processor(dialect)
+
+        def process(value):
+            return f"DateTime64({parent(value)})"
+
+        return process

ydb_sqlalchemy/sqlalchemy/test_sqlalchemy.py

@@ -1,3 +1,4 @@
+from datetime import date
 import sqlalchemy as sa
 
 from . import YqlDialect, types
@@ -25,3 +26,12 @@ def test_casts():
         "CAST(1/2 AS UInt8)",
         "String::JoinFromList(ListMap(TOPFREQ(1/2, 5), ($x) -> { RETURN CAST($x AS UTF8) ;}), ', ')",
     ]
+
+
+def test_ydb_types():
+    dialect = YqlDialect()
+
+    query = sa.literal(date(1996, 11, 19))
+    compiled = query.compile(dialect=dialect, compile_kwargs={"literal_binds": True})
+
+    assert str(compiled) == "Date('1996-11-19')"

ydb_sqlalchemy/sqlalchemy/types.py

@@ -1,3 +1,4 @@
+import decimal
 from typing import Any, Mapping, Type, Union
 
 from sqlalchemy import __version__ as sa_version
@@ -10,7 +11,7 @@ else:
 from sqlalchemy import ARRAY, exc, types
 from sqlalchemy.sql import type_api
 
-from .datetime_types import YqlDateTime, YqlTimestamp  # noqa: F401
+from .datetime_types import YqlDate, YqlDateTime, YqlTimestamp, YqlDate32, YqlTimestamp64, YqlDateTime64  # noqa: F401
 from .json import YqlJSON  # noqa: F401
 
 
@@ -46,6 +47,66 @@ class Int8(types.Integer):
     __visit_name__ = "int8"
 
 
+class Decimal(types.DECIMAL):
+    __visit_name__ = "DECIMAL"
+
+    def __init__(self, precision=None, scale=None, asdecimal=True):
+        # YDB supports Decimal(22,9) by default
+        if precision is None:
+            precision = 22
+        if scale is None:
+            scale = 9
+        super().__init__(precision=precision, scale=scale, asdecimal=asdecimal)
+
+    def bind_processor(self, dialect):
+        def process(value):
+            if value is None:
+                return None
+            # Convert float to Decimal if needed
+            if isinstance(value, float):
+                return decimal.Decimal(str(value))
+            elif isinstance(value, str):
+                return decimal.Decimal(value)
+            elif not isinstance(value, decimal.Decimal):
+                return decimal.Decimal(str(value))
+            return value
+
+        return process
+
+    def result_processor(self, dialect, coltype):
+        def process(value):
+            if value is None:
+                return None
+
+            # YDB always returns Decimal values as decimal.Decimal objects
+            # But if asdecimal=False, we should convert to float
+            if not self.asdecimal:
+                return float(value)
+
+            # For asdecimal=True (default), return as Decimal
+            if not isinstance(value, decimal.Decimal):
+                return decimal.Decimal(str(value))
+            return value
+
+        return process
+
+    def literal_processor(self, dialect):
+        def process(value):
+            # Convert float to Decimal if needed
+            if isinstance(value, float):
+                value = decimal.Decimal(str(value))
+            elif not isinstance(value, decimal.Decimal):
+                value = decimal.Decimal(str(value))
+
+            # Use default precision and scale if not specified
+            precision = self.precision if self.precision is not None else 22
+            scale = self.scale if self.scale is not None else 9
+
+            return f'Decimal("{str(value)}", {precision}, {scale})'
+
+        return process
+
+
 class ListType(ARRAY):
     __visit_name__ = "list_type"
 

ydb_sqlalchemy-0.1.11.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.1
+Name: ydb-sqlalchemy
+Version: 0.1.11
+Summary: YDB Dialect for SQLAlchemy
+Home-page: http://github.com/ydb-platform/ydb-sqlalchemy
+Author: Yandex LLC
+Author-email: ydb@yandex-team.ru
+License: Apache 2.0
+Keywords: SQLAlchemy YDB YQL
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sqlalchemy <3.0.0,>=1.4.0
+Requires-Dist: ydb >=3.21.6
+Requires-Dist: ydb-dbapi >=0.1.10
+Provides-Extra: yc
+Requires-Dist: yandexcloud ; extra == 'yc'
+
+# YDB Dialect for SQLAlchemy
+---
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ydb-platform/ydb-sqlalchemy/blob/main/LICENSE)
+[![PyPI version](https://badge.fury.io/py/ydb-sqlalchemy.svg)](https://badge.fury.io/py/ydb-sqlalchemy)
+[![API Reference](https://img.shields.io/badge/API-Reference-lightgreen.svg)](https://ydb-platform.github.io/ydb-sqlalchemy/api/index.html)
+[![Functional tests](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/tests.yml/badge.svg)](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/tests.yml)
+[![Style checks](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/style.yml/badge.svg)](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/style.yml)
+
+This repository contains YQL dialect for SqlAlchemy 2.0.
+
+---
+
+**Documentation**: <a href="https://ydb-platform.github.io/ydb-sqlalchemy" target="_blank">https://ydb-platform.github.io/ydb-sqlalchemy</a>
+
+---
+
+**Note**: Dialect also works with SqlAlchemy 1.4, but it is not fully tested.
+
+
+## Installation
+
+### Via PyPI
+To install ydb-sqlalchemy from PyPI:
+
+```bash
+$ pip install ydb-sqlalchemy
+```
+
+### Installation from source code
+To work with current ydb-sqlalchemy version clone this repo and run from source root:
+
+```bash
+$ pip install -U .
+```
+
+## Getting started
+
+Connect to local YDB using SqlAlchemy:
+
+```python3
+import sqlalchemy as sa
+
+
+engine = sa.create_engine("yql+ydb://localhost:2136/local")
+
+with engine.connect() as conn:
+  rs = conn.execute(sa.text("SELECT 1 AS value"))
+  print(rs.fetchone())
+
+```
+
+## Authentication
+
+To specify credentials, you should pass `credentials` object to `connect_args` argument of `create_engine` method.
+
+### Static Credentials
+
+To use static credentials you should specify `username` and `password` as follows:
+
+```python3
+engine = sa.create_engine(
+    "yql+ydb://localhost:2136/local",
+    connect_args = {
+        "credentials": {
+            "username": "...",
+            "password": "..."
+        }
+    }
+)
+```
+
+### Token Credentials
+
+To use access token credentials you should specify `token` as follows:
+
+```python3
+engine = sa.create_engine(
+    "yql+ydb://localhost:2136/local",
+    connect_args = {
+        "credentials": {
+            "token": "..."
+        }
+    }
+)
+```
+
+### Service Account Credentials
+
+To use service account credentials you should specify `service_account_json` as follows:
+
+```python3
+engine = sa.create_engine(
+    "yql+ydb://localhost:2136/local",
+    connect_args = {
+        "credentials": {
+            "service_account_json": {
+                "id": "...",
+                "service_account_id": "...",
+                "created_at": "...",
+                "key_algorithm": "...",
+                "public_key": "...",
+                "private_key": "..."
+            }
+        }
+    }
+)
+```
+
+### Credentials from YDB SDK
+
+To use any credentials that comes with `ydb` package, just pass credentials object as follows:
+
+```python3
+import ydb.iam
+
+engine = sa.create_engine(
+    "yql+ydb://localhost:2136/local",
+    connect_args = {
+        "credentials": ydb.iam.MetadataUrlCredentials()
+    }
+)
+
+```
+
+
+## Migrations
+
+To setup `alembic` to work with `YDB` please check [this example](https://github.com/ydb-platform/ydb-sqlalchemy/tree/main/examples/alembic).
+
+## Development
+
+### Run Tests:
+
+Run the command from the root directory of the repository to start YDB in a local docker container.
+```bash
+$ docker-compose up
+```
+
+To run all tests execute the command from the root directory of the repository:
+```bash
+$ tox -e test-all
+```
+
+Run specific test:
+```bash
+$ tox -e test -- test/test_core.py
+```
+
+Check code style:
+```bash
+$ tox -e style
+```
+
+Reformat code:
+```bash
+$ tox -e isort
+$ tox -e black-format
+```
+
+Run example (needs running local YDB):
+```bash
+$ python -m pip install virtualenv
+$ virtualenv venv
+$ source venv/bin/activate
+$ pip install -r requirements.txt
+$ python examples/example.py
+```
+
+## Additional Notes
+
+### Pandas
+It is possible to use YDB SA engine with `pandas` fuctions [to_sql()](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html) and [read_sql](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql.html). However, there are some limitations:
+
+* `to_sql` method can not be used with column tables, since it is impossible to specify `NOT NULL` columns with current `to_sql` arguments. YDB requires column tables to have `NOT NULL` attribute on `PK` columns.
+
+* `to_sql` is not fully optimized to load huge datasets. It is recommended to use `method="multi"` and avoid setting a very large `chunksize`.
+
+* `read_sql` is not fully optimized to load huge datasets and could lead to significant memory consumptions.

ydb_sqlalchemy-0.1.11.dist-info/RECORD

@@ -0,0 +1,26 @@
+test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+test/conftest.py,sha256=rhWa0EQB9EwO_wAwxPdK17Qi582DdbBE8p5Gv4180Ds,570
+test/test_core.py,sha256=XvPJ0MtWK2gqGytps4YMUpHtJWKlEqN1rQBUpeeelAg,42859
+test/test_inspect.py,sha256=c4kc3jc48MCOfllO-ciiYf1vO-HOfuv0xVoXYT1Jxro,1106
+test/test_orm.py,sha256=jQVVld50zbUwxwgW9ySIWGaNDEOLzHKXjTkdpsG9TpA,1825
+test/test_suite.py,sha256=XIW5kxJNKGK4FKE_nza-379_OFOwhP8zcsXEC0lPqWY,30569
+ydb_sqlalchemy/__init__.py,sha256=hX7Gy-KOiHk7B5-0wj3ZmLjk4YDJnSMHIAqxVGn_PJY,181
+ydb_sqlalchemy/_version.py,sha256=ZYmaLdPDGWutBbfaGi2OftPL61_FbKbiiNjA7KrAwGs,19
+ydb_sqlalchemy/sqlalchemy/__init__.py,sha256=YAj29mdu0GEG0Udoo0p5ANmEyH6OsAKz5FZc0qn6FDY,16570
+ydb_sqlalchemy/sqlalchemy/datetime_types.py,sha256=wrI9kpsI_f7Jhbm7Fu0o_S1QoGCLIe6A9jfUwb41aMM,1929
+ydb_sqlalchemy/sqlalchemy/dbapi_adapter.py,sha256=HsO4Vhv2nj_Qowt23mUH-jRuNdWKV3ryKnZG5OFp5m0,3109
+ydb_sqlalchemy/sqlalchemy/dml.py,sha256=k_m6PLOAY7dVzG1gsyo2bB3Lp-o3rhzN0oSX_nfkbFU,310
+ydb_sqlalchemy/sqlalchemy/json.py,sha256=b4ydjlQjBhlhqGP_Sy2uZVKmt__D-9M7-YLGQMdYGME,1043
+ydb_sqlalchemy/sqlalchemy/requirements.py,sha256=zm6fcLormtk3KHnbtrBvxfkbG9ZyzNan38HrRB6vC3c,2505
+ydb_sqlalchemy/sqlalchemy/test_sqlalchemy.py,sha256=QPRgUPsTOqAf0gzWjidsIhTPVkfOILy4SCSgNb1GE7o,1039
+ydb_sqlalchemy/sqlalchemy/types.py,sha256=BVeC8RSa2nFnI3-Q7XZxCnAolHc_k_kMCfWhUmbi5wo,3823
+ydb_sqlalchemy/sqlalchemy/compiler/__init__.py,sha256=QqA6r-_bw1R97nQZy5ZSJN724znXg88l4mi5PpqAOxI,492
+ydb_sqlalchemy/sqlalchemy/compiler/base.py,sha256=FKtVDKl33hGLcIKpV0UR2ppQ-X2XJ5oyh10FXw4I2uY,19220
+ydb_sqlalchemy/sqlalchemy/compiler/sa14.py,sha256=LanxAnwOiMnsnrY05B0jpmvGn5NXuOKMcxi_6N3obVM,1186
+ydb_sqlalchemy/sqlalchemy/compiler/sa20.py,sha256=rvVhe-pq5bOyuW4KMMMAD7JIWMzy355eijymBvuPwKw,3421
+ydb_sqlalchemy-0.1.11.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ydb_sqlalchemy-0.1.11.dist-info/METADATA,sha256=wnHV82yNZg1Q5ZRAzHdO6UnOpGRLqOlF-ob2YJPObKM,5395
+ydb_sqlalchemy-0.1.11.dist-info/WHEEL,sha256=Ll72iyqtt6Rbxp-Q7FSafYA1LeRv98X15xcZWRsFEmY,109
+ydb_sqlalchemy-0.1.11.dist-info/entry_points.txt,sha256=iJxbKYuliWNBmL0iIiw8MxvOXrSEz5xe5fuEBqMRwCE,267
+ydb_sqlalchemy-0.1.11.dist-info/top_level.txt,sha256=iS69Y1GTAcTok0u0oQdxP-Q5iVgUGI71XBsaEUrWhMg,20
+ydb_sqlalchemy-0.1.11.dist-info/RECORD,,

ydb_sqlalchemy-0.1.9.dist-info/METADATA

@@ -1,104 +0,0 @@
-Metadata-Version: 2.1
-Name: ydb-sqlalchemy
-Version: 0.1.9
-Summary: YDB Dialect for SQLAlchemy
-Home-page: http://github.com/ydb-platform/ydb-sqlalchemy
-Author: Yandex LLC
-Author-email: ydb@yandex-team.ru
-License: Apache 2.0
-Keywords: SQLAlchemy YDB YQL
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: sqlalchemy <3.0.0,>=1.4.0
-Requires-Dist: ydb >=3.18.8
-Requires-Dist: ydb-dbapi >=0.1.10
-Provides-Extra: yc
-Requires-Dist: yandexcloud ; extra == 'yc'
-
-# YDB Dialect for SQLAlchemy
----
-[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ydb-platform/ydb-sqlalchemy/blob/main/LICENSE)
-[![PyPI version](https://badge.fury.io/py/ydb-sqlalchemy.svg)](https://badge.fury.io/py/ydb-sqlalchemy)
-[![Functional tests](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/tests.yml/badge.svg)](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/tests.yml)
-[![Style checks](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/style.yml/badge.svg)](https://github.com/ydb-platform/ydb-sqlalchemy/actions/workflows/style.yml)
-
-This repository contains YQL dialect for SqlAlchemy 2.0.
-
-**Note**: Dialect also works with SqlAlchemy 1.4, but it is not fully tested.
-
-
-## Installation
-
-### Via PyPI
-To install ydb-sqlalchemy from PyPI:
-
-```bash
-$ pip install ydb-sqlalchemy
-```
-
-### Installation from source code
-To work with current ydb-sqlalchemy version clone this repo and run from source root:
-
-```bash
-$ pip install -U .
-```
-
-## Getting started
-
-Connect to local YDB using SqlAlchemy:
-
-```python3
-import sqlalchemy as sa
-
-
-engine = sa.create_engine("yql+ydb://localhost:2136/local")
-
-with engine.connect() as conn:
-  rs = conn.execute(sa.text("SELECT 1 AS value"))
-  print(rs.fetchone())
-
-```
-
-To setup `alembic` to work with `YDB` please check [this example](https://github.com/ydb-platform/ydb-sqlalchemy/tree/main/examples/alembic).
-
-## Development
-
-### Run Tests:
-
-Run the command from the root directory of the repository to start YDB in a local docker container.
-```bash
-$ docker-compose up
-```
-
-To run all tests execute the command from the root directory of the repository:
-```bash
-$ tox -e test-all
-```
-
-Run specific test:
-```bash
-$ tox -e test -- test/test_core.py
-```
-
-Check code style:
-```bash
-$ tox -e style
-```
-
-Reformat code:
-```bash
-$ tox -e isort
-$ tox -e black-format
-```
-
-Run example (needs running local YDB):
-```bash
-$ python -m pip install virtualenv
-$ virtualenv venv
-$ source venv/bin/activate
-$ pip install -r requirements.txt
-$ python examples/example.py
-```

ydb_sqlalchemy-0.1.9.dist-info/RECORD

@@ -1,26 +0,0 @@
-test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-test/conftest.py,sha256=rhWa0EQB9EwO_wAwxPdK17Qi582DdbBE8p5Gv4180Ds,570
-test/test_core.py,sha256=XvPJ0MtWK2gqGytps4YMUpHtJWKlEqN1rQBUpeeelAg,42859
-test/test_inspect.py,sha256=c4kc3jc48MCOfllO-ciiYf1vO-HOfuv0xVoXYT1Jxro,1106
-test/test_orm.py,sha256=jQVVld50zbUwxwgW9ySIWGaNDEOLzHKXjTkdpsG9TpA,1825
-test/test_suite.py,sha256=peBlmjGpdvhkGQM0w0ulBtX2U-7V-nqqeQmm2RgAH7w,19568
-ydb_sqlalchemy/__init__.py,sha256=hX7Gy-KOiHk7B5-0wj3ZmLjk4YDJnSMHIAqxVGn_PJY,181
-ydb_sqlalchemy/_version.py,sha256=V3G9KvW0YJgXF7ujb-Y3MU9L6nKQa_pL4l-az9Fly0w,18
-ydb_sqlalchemy/sqlalchemy/__init__.py,sha256=GXkc4N-margcHMdZc1_xeB748y0SX2gDzgbGQONu1H4,16356
-ydb_sqlalchemy/sqlalchemy/datetime_types.py,sha256=MlH4YGlNeo0YihHX8ZiSIEkPdyRVL2QWP0wj-uxqzTI,914
-ydb_sqlalchemy/sqlalchemy/dbapi_adapter.py,sha256=HsO4Vhv2nj_Qowt23mUH-jRuNdWKV3ryKnZG5OFp5m0,3109
-ydb_sqlalchemy/sqlalchemy/dml.py,sha256=k_m6PLOAY7dVzG1gsyo2bB3Lp-o3rhzN0oSX_nfkbFU,310
-ydb_sqlalchemy/sqlalchemy/json.py,sha256=b4ydjlQjBhlhqGP_Sy2uZVKmt__D-9M7-YLGQMdYGME,1043
-ydb_sqlalchemy/sqlalchemy/requirements.py,sha256=zm6fcLormtk3KHnbtrBvxfkbG9ZyzNan38HrRB6vC3c,2505
-ydb_sqlalchemy/sqlalchemy/test_sqlalchemy.py,sha256=HSNDtmqYXf5aR1hDtzioQV9YzHALK7NPerFxZRWn7hk,782
-ydb_sqlalchemy/sqlalchemy/types.py,sha256=sTL3VCMs-UvYONZfheYgSVOyPd4udVYOMz4A6BtauUw,1694
-ydb_sqlalchemy/sqlalchemy/compiler/__init__.py,sha256=QqA6r-_bw1R97nQZy5ZSJN724znXg88l4mi5PpqAOxI,492
-ydb_sqlalchemy/sqlalchemy/compiler/base.py,sha256=BfaK1J-wBkixKuH1944b0dfDrZ1D4xWU9WmHDy3KM94,18378
-ydb_sqlalchemy/sqlalchemy/compiler/sa14.py,sha256=LanxAnwOiMnsnrY05B0jpmvGn5NXuOKMcxi_6N3obVM,1186
-ydb_sqlalchemy/sqlalchemy/compiler/sa20.py,sha256=rvVhe-pq5bOyuW4KMMMAD7JIWMzy355eijymBvuPwKw,3421
-ydb_sqlalchemy-0.1.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ydb_sqlalchemy-0.1.9.dist-info/METADATA,sha256=PFa6IKaOU1Q1rCSsiDk7joOJxPf5Bp4R8yIZJukBh_k,2722
-ydb_sqlalchemy-0.1.9.dist-info/WHEEL,sha256=Ll72iyqtt6Rbxp-Q7FSafYA1LeRv98X15xcZWRsFEmY,109
-ydb_sqlalchemy-0.1.9.dist-info/entry_points.txt,sha256=iJxbKYuliWNBmL0iIiw8MxvOXrSEz5xe5fuEBqMRwCE,267
-ydb_sqlalchemy-0.1.9.dist-info/top_level.txt,sha256=iS69Y1GTAcTok0u0oQdxP-Q5iVgUGI71XBsaEUrWhMg,20
-ydb_sqlalchemy-0.1.9.dist-info/RECORD,,