ydb-sqlalchemy 0.1.14__tar.gz → 0.1.16__tar.gz

{ydb_sqlalchemy-0.1.14/ydb_sqlalchemy.egg-info → ydb_sqlalchemy-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ydb-sqlalchemy
-Version: 0.1.14
+Version: 0.1.16
 Summary: YDB Dialect for SQLAlchemy
 Home-page: http://github.com/ydb-platform/ydb-sqlalchemy
 Author: Yandex LLC

{ydb_sqlalchemy-0.1.14 → ydb_sqlalchemy-0.1.16}/setup.py

@@ -13,7 +13,7 @@ with open("requirements.txt") as f:
 
 setuptools.setup(
     name="ydb-sqlalchemy",
-    version="0.1.14",  # AUTOVERSION
+    version="0.1.16",  # AUTOVERSION
     description="YDB Dialect for SQLAlchemy",
     author="Yandex LLC",
     author_email="ydb@yandex-team.ru",

{ydb_sqlalchemy-0.1.14 → ydb_sqlalchemy-0.1.16}/test/test_core.py

@@ -181,12 +181,19 @@ class TestSimpleSelect(TablesTest):
         rows = connection.execute(stm).fetchall()
         assert set(rows) == {(1,), (2,), (3,), (4,), (6,), (7,)}
 
+        # LIMIT
+        rows = connection.execute(tb.select().order_by(tb.c.id).limit(2)).fetchall()
+        assert rows == [
+            (1, "some text", Decimal("3.141592653")),
+            (2, "test text", Decimal("3.14159265")),
+        ]
+
         # LIMIT/OFFSET
-        # rows = connection.execute(tb.select().order_by(tb.c.id).limit(2)).fetchall()
-        # assert rows == [
-        #     (1, "some text", Decimal("3.141592653")),
-        #     (2, "test text", Decimal("3.14159265")),
-        # ]
+        rows = connection.execute(tb.select().order_by(tb.c.id).limit(2).offset(1)).fetchall()
+        assert rows == [
+            (2, "test text", Decimal("3.14159265")),
+            (3, "test test", Decimal("3.1415926")),
+        ]
 
         # ORDER BY ASC
         rows = connection.execute(sa.select(tb.c.id).order_by(tb.c.id)).fetchall()
@@ -223,11 +230,20 @@ class TestTypes(TablesTest):
             "test_primitive_types",
             metadata,
             Column("int", sa.Integer, primary_key=True),
-            # Column("bin", sa.BINARY),
+            Column("bin", sa.BINARY),
             Column("str", sa.String),
             Column("float", sa.Float),
             Column("bool", sa.Boolean),
         )
+        Table(
+            "test_all_binary_types",
+            metadata,
+            Column("id", sa.Integer, primary_key=True),
+            Column("bin", sa.BINARY),
+            Column("large_bin", sa.LargeBinary),
+            Column("blob", sa.BLOB),
+            Column("custom_bin", types.Binary),
+        )
         Table(
             "test_datetime_types",
             metadata,
@@ -244,7 +260,7 @@ class TestTypes(TablesTest):
 
         statement = sa.insert(table).values(
             int=42,
-            # bin=b"abc",
+            bin=b"abc",
             str="Hello World!",
             float=3.5,
             bool=True,
@@ -253,7 +269,22 @@ class TestTypes(TablesTest):
         connection.execute(statement)
 
         row = connection.execute(sa.select(table)).fetchone()
-        assert row == (42, "Hello World!", 3.5, True)
+        assert row == (42, b"abc", "Hello World!", 3.5, True)
+
+    def test_all_binary_types(self, connection):
+        table = self.tables.test_all_binary_types
+        data = {
+            "id": 1,
+            "bin": b"binary",
+            "large_bin": b"large_binary",
+            "blob": b"blob",
+            "custom_bin": b"custom_binary",
+        }
+        statement = sa.insert(table).values(**data)
+        connection.execute(statement)
+
+        row = connection.execute(sa.select(table)).fetchone()
+        assert row == (1, b"binary", b"large_binary", b"blob", b"custom_binary")
 
     def test_integer_types(self, connection):
         stmt = sa.select(
@@ -1112,3 +1143,154 @@ class TestTablePathPrefix(TablesTest):
         metadata.reflect(reflection_engine)
 
         assert "nested_dir/table" in metadata.tables
+
+
+class TestAsTable(TablesTest):
+    __backend__ = True
+
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "test_as_table",
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("val_int", Integer, nullable=True),
+            Column("val_str", String, nullable=True),
+        )
+        Table(
+            "test_as_table_json",
+            metadata,
+            Column("id", Integer, primary_key=True),
+            Column("data", sa.JSON, nullable=True),
+        )
+
+    @pytest.mark.parametrize("list_cls", [types.ListType, sa.ARRAY])
+    def test_upsert_as_table(self, connection, list_cls):
+        table = self.tables.test_as_table
+
+        input_data = [
+            {"id": 1, "val_int": 10, "val_str": "a"},
+            {"id": 2, "val_int": None, "val_str": "b"},
+            {"id": 3, "val_int": 30, "val_str": None},
+        ]
+
+        struct_type = types.StructType(
+            {
+                "id": Integer,
+                "val_int": types.Optional(Integer),
+                "val_str": types.Optional(String),
+            }
+        )
+        list_type = list_cls(struct_type)
+
+        bind_param = sa.bindparam("data", type_=list_type)
+
+        upsert_stm = ydb_sa.upsert(table).from_select(
+            ["id", "val_int", "val_str"],
+            sa.select(
+                sa.column("id", type_=Integer), sa.column("val_int", type_=Integer), sa.column("val_str", type_=String)
+            ).select_from(sa.func.AS_TABLE(bind_param)),
+        )
+
+        connection.execute(upsert_stm, {"data": input_data})
+
+        rows = connection.execute(sa.select(table).order_by(table.c.id)).fetchall()
+        assert rows == [
+            (1, 10, "a"),
+            (2, None, "b"),
+            (3, 30, None),
+        ]
+
+    @pytest.mark.parametrize("list_cls", [types.ListType, sa.ARRAY])
+    def test_upsert_from_table_json(self, connection, list_cls):
+        table = self.tables.test_as_table_json
+
+        input_data = [
+            {"id": 1, "data": {"a": 1}},
+            {"id": 2, "data": [1, 2, 3]},
+            {"id": 3, "data": None},
+        ]
+
+        struct_type = types.StructType.from_table(table)
+        list_type = list_cls(struct_type)
+
+        bind_param = sa.bindparam("input_data", type_=list_type)
+
+        cols = [sa.column(c.name, type_=c.type) for c in table.columns]
+        upsert_stm = ydb_sa.upsert(table).from_select(
+            [c.name for c in table.columns],
+            sa.select(*cols).select_from(sa.func.AS_TABLE(bind_param)),
+        )
+
+        connection.execute(upsert_stm, {"input_data": input_data})
+
+        rows = connection.execute(sa.select(table).order_by(table.c.id)).fetchall()
+
+        assert rows == [
+            (1, {"a": 1}),
+            (2, [1, 2, 3]),
+            (3, None),
+        ]
+
+    @pytest.mark.parametrize("list_cls", [types.ListType, sa.ARRAY])
+    def test_insert_as_table(self, connection, list_cls):
+        table = self.tables.test_as_table
+
+        input_data = [
+            {"id": 4, "val_int": 40, "val_str": "d"},
+            {"id": 5, "val_int": None, "val_str": "e"},
+        ]
+
+        struct_type = types.StructType(
+            {
+                "id": Integer,
+                "val_int": types.Optional(Integer),
+                "val_str": types.Optional(String),
+            }
+        )
+        list_type = list_cls(struct_type)
+
+        bind_param = sa.bindparam("data", type_=list_type)
+
+        insert_stm = sa.insert(table).from_select(
+            ["id", "val_int", "val_str"],
+            sa.select(
+                sa.column("id", type_=Integer), sa.column("val_int", type_=Integer), sa.column("val_str", type_=String)
+            ).select_from(sa.func.AS_TABLE(bind_param)),
+        )
+
+        connection.execute(insert_stm, {"data": input_data})
+
+        rows = connection.execute(sa.select(table).where(table.c.id >= 4).order_by(table.c.id)).fetchall()
+        assert rows == [
+            (4, 40, "d"),
+            (5, None, "e"),
+        ]
+
+    @pytest.mark.parametrize("list_cls", [types.ListType, sa.ARRAY])
+    def test_upsert_from_table_reflection(self, connection, list_cls):
+        table = self.tables.test_as_table
+
+        input_data = [
+            {"id": 1, "val_int": 10, "val_str": "a"},
+            {"id": 2, "val_int": None, "val_str": "b"},
+        ]
+
+        struct_type = types.StructType.from_table(table)
+        list_type = list_cls(struct_type)
+
+        bind_param = sa.bindparam("data", type_=list_type)
+
+        cols = [sa.column(c.name, type_=c.type) for c in table.columns]
+        upsert_stm = ydb_sa.upsert(table).from_select(
+            [c.name for c in table.columns],
+            sa.select(*cols).select_from(sa.func.AS_TABLE(bind_param)),
+        )
+
+        connection.execute(upsert_stm, {"data": input_data})
+
+        rows = connection.execute(sa.select(table).order_by(table.c.id)).fetchall()
+        assert rows == [
+            (1, 10, "a"),
+            (2, None, "b"),
+        ]

{ydb_sqlalchemy-0.1.14 → ydb_sqlalchemy-0.1.16}/test/test_suite.py

@@ -274,7 +274,6 @@ class NumericTest(_NumericTest):
     pass
 
 
-@pytest.mark.skip("TODO: see issue #13")
 class BinaryTest(_BinaryTest):
     pass
 

ydb_sqlalchemy-0.1.16/ydb_sqlalchemy/_version.py

@@ -0,0 +1 @@
+VERSION = "0.1.16"

{ydb_sqlalchemy-0.1.14 → ydb_sqlalchemy-0.1.16}/ydb_sqlalchemy/sqlalchemy/__init__.py

@@ -157,6 +157,10 @@ class YqlDialect(StrCompileDialect):
         sa.types.DATETIME: types.YqlDateTime,
         sa.types.TIMESTAMP: types.YqlTimestamp,
         sa.types.DECIMAL: types.Decimal,
+        sa.types.BINARY: types.Binary,
+        sa.types.LargeBinary: types.Binary,
+        sa.types.BLOB: types.Binary,
+        sa.types.ARRAY: types.ListType,
     }
 
     connection_characteristics = util.immutabledict(

{ydb_sqlalchemy-0.1.14 → ydb_sqlalchemy-0.1.16}/ydb_sqlalchemy/sqlalchemy/compiler/base.py

@@ -12,6 +12,7 @@ from sqlalchemy.sql.compiler import (
     StrSQLTypeCompiler,
     selectable,
 )
+from sqlalchemy.sql.type_api import to_instance
 from typing import (
     Any,
     Dict,
@@ -24,6 +25,12 @@ from typing import (
     Union,
 )
 
+try:
+    from sqlalchemy.types import _Binary as _BinaryType
+except ImportError:
+    # For older sqlalchemy versions
+    from sqlalchemy.sql.sqltypes import _Binary as _BinaryType
+
 
 from .. import types
 
@@ -37,19 +44,6 @@ else:
     from sqlalchemy import Cast as _cast
 
 
-STR_QUOTE_MAP = {
-    "'": "\\'",
-    "\\": "\\\\",
-    "\0": "\\0",
-    "\b": "\\b",
-    "\f": "\\f",
-    "\r": "\\r",
-    "\n": "\\n",
-    "\t": "\\t",
-    "%": "%%",
-}
-
-
 COMPOUND_KEYWORDS = {
     selectable.CompoundSelect.UNION: "UNION ALL",
     selectable.CompoundSelect.UNION_ALL: "UNION ALL",
@@ -60,6 +54,19 @@ COMPOUND_KEYWORDS = {
 }
 
 
+ESCAPE_RULES = [
+    ("\\", "\\\\"),  # Must be first to avoid double escaping
+    ("'", "\\'"),
+    ("\0", "\\0"),
+    ("\b", "\\b"),
+    ("\f", "\\f"),
+    ("\r", "\\r"),
+    ("\n", "\\n"),
+    ("\t", "\\t"),
+    ("%", "%%"),
+]
+
+
 class BaseYqlTypeCompiler(StrSQLTypeCompiler):
     def visit_JSON(self, type_: Union[sa.JSON, types.YqlJSON], **kw):
         return "JSON"
@@ -152,11 +159,17 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
         inner = self.process(type_.item_type, **kw)
         return f"List<{inner}>"
 
+    def visit_optional(self, type_: types.Optional, **kw):
+        el = to_instance(type_.element_type)
+        inner = self.process(el, **kw)
+        return f"Optional<{inner}>"
+
     def visit_struct_type(self, type_: types.StructType, **kw):
-        text = "Struct<"
-        for field, field_type in type_.fields_types:
-            text += f"{field}:{self.process(field_type, **kw)}"
-        return text + ">"
+        rendered_types = []
+        for field, field_type in type_.fields_types.items():
+            type_str = self.process(field_type, **kw)
+            rendered_types.append(f"{field}:{type_str}")
+        return f"Struct<{','.join(rendered_types)}>"
 
     def get_ydb_type(
         self, type_: sa.types.TypeEngine, is_optional: bool
@@ -167,6 +180,10 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
         if isinstance(type_, (sa.Text, sa.String)):
             ydb_type = ydb.PrimitiveType.Utf8
 
+        elif isinstance(type_, types.Optional):
+            inner = to_instance(type_.element_type)
+            return self.get_ydb_type(inner, is_optional=True)
+
         # Integers
         elif isinstance(type_, types.UInt64):
             ydb_type = ydb.PrimitiveType.Uint64
@@ -216,7 +233,7 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
             ydb_type = ydb.PrimitiveType.Timestamp
         elif isinstance(type_, sa.Date):
             ydb_type = ydb.PrimitiveType.Date
-        elif isinstance(type_, sa.BINARY):
+        elif isinstance(type_, _BinaryType):
             ydb_type = ydb.PrimitiveType.String
         elif isinstance(type_, sa.Float):
             ydb_type = ydb.PrimitiveType.Float
@@ -235,7 +252,8 @@ class BaseYqlTypeCompiler(StrSQLTypeCompiler):
         elif isinstance(type_, types.StructType):
             ydb_type = ydb.StructType()
             for field, field_type in type_.fields_types.items():
-                ydb_type.add_member(field, self.get_ydb_type(field_type(), is_optional=False))
+                inner_type = to_instance(field_type)
+                ydb_type.add_member(field, self.get_ydb_type(inner_type, is_optional=False))
         else:
             raise NotSupportedError(f"{type_} bind variables not supported")
 
@@ -275,7 +293,8 @@ class BaseYqlCompiler(StrSQLCompiler):
 
     def render_literal_value(self, value, type_):
         if isinstance(value, str):
-            value = "".join(STR_QUOTE_MAP.get(x, x) for x in value)
+            for pattern, replacement in ESCAPE_RULES:
+                value = value.replace(pattern, replacement)
             return f"'{value}'"
         return super().render_literal_value(value, type_)
 

ydb_sqlalchemy-0.1.16/ydb_sqlalchemy/sqlalchemy/test_sqlalchemy.py

@@ -0,0 +1,145 @@
+from datetime import date
+import sqlalchemy as sa
+
+from . import YqlDialect, types
+
+
+def test_casts():
+    dialect = YqlDialect()
+    expr = sa.literal_column("1/2")
+
+    res_exprs = [
+        sa.cast(expr, types.UInt32),
+        sa.cast(expr, types.UInt64),
+        sa.cast(expr, types.UInt8),
+        sa.func.String.JoinFromList(
+            sa.func.ListMap(sa.func.TOPFREQ(expr, 5), types.Lambda(lambda x: sa.cast(x, sa.Text))),
+            ", ",
+        ),
+    ]
+
+    strs = [str(res_expr.compile(dialect=dialect, compile_kwargs={"literal_binds": True})) for res_expr in res_exprs]
+
+    assert strs == [
+        "CAST(1/2 AS UInt32)",
+        "CAST(1/2 AS UInt64)",
+        "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')"
+
+
+def test_binary_type():
+    dialect = YqlDialect()
+    expr = sa.literal(b"some bytes")
+    compiled = expr.compile(dialect=dialect, compile_kwargs={"literal_binds": True})
+    assert str(compiled) == "'some bytes'"
+
+    expr_binary = sa.cast(expr, sa.BINARY)
+    compiled_binary = expr_binary.compile(dialect=dialect, compile_kwargs={"literal_binds": True})
+    assert str(compiled_binary) == "CAST('some bytes' AS String)"
+
+
+def test_all_binary_types():
+    dialect = YqlDialect()
+    expr = sa.literal(b"some bytes")
+
+    binary_types = [
+        sa.BINARY,
+        sa.LargeBinary,
+        sa.BLOB,
+        types.Binary,
+    ]
+
+    for type_ in binary_types:
+        expr_binary = sa.cast(expr, type_)
+        compiled_binary = expr_binary.compile(dialect=dialect, compile_kwargs={"literal_binds": True})
+        assert str(compiled_binary) == "CAST('some bytes' AS String)"
+
+
+def test_struct_type_generation():
+    dialect = YqlDialect()
+    type_compiler = dialect.type_compiler
+
+    # Test default (non-optional)
+    struct_type = types.StructType(
+        {
+            "id": sa.Integer,
+            "val_int": sa.Integer,
+        }
+    )
+    ydb_type = type_compiler.get_ydb_type(struct_type, is_optional=False)
+    # Keys are sorted
+    assert str(ydb_type) == "Struct<id:Int64,val_int:Int64>"
+
+    # Test optional
+    struct_type_opt = types.StructType(
+        {
+            "id": sa.Integer,
+            "val_int": types.Optional(sa.Integer),
+        }
+    )
+    ydb_type_opt = type_compiler.get_ydb_type(struct_type_opt, is_optional=False)
+    assert str(ydb_type_opt) == "Struct<id:Int64,val_int:Int64?>"
+
+
+def test_types_compilation():
+    dialect = YqlDialect()
+
+    def compile_type(type_):
+        return dialect.type_compiler.process(type_)
+
+    assert compile_type(types.UInt64()) == "UInt64"
+    assert compile_type(types.UInt32()) == "UInt32"
+    assert compile_type(types.UInt16()) == "UInt16"
+    assert compile_type(types.UInt8()) == "UInt8"
+
+    assert compile_type(types.Int64()) == "Int64"
+    assert compile_type(types.Int32()) == "Int32"
+    assert compile_type(types.Int16()) == "Int32"
+    assert compile_type(types.Int8()) == "Int8"
+
+    assert compile_type(types.ListType(types.Int64())) == "List<Int64>"
+
+    struct = types.StructType({"a": types.Int32(), "b": types.ListType(types.Int32())})
+    # Ordered by key: a, b
+    assert compile_type(struct) == "Struct<a:Int32,b:List<Int32>>"
+
+
+def test_optional_type_compilation():
+    dialect = YqlDialect()
+    type_compiler = dialect.type_compiler
+
+    def compile_type(type_):
+        return type_compiler.process(type_)
+
+    # Test Optional(Integer)
+    opt_int = types.Optional(sa.Integer)
+    assert compile_type(opt_int) == "Optional<Int64>"
+
+    # Test Optional(String)
+    opt_str = types.Optional(sa.String)
+    assert compile_type(opt_str) == "Optional<UTF8>"
+
+    # Test Nested Optional
+    opt_opt_int = types.Optional(types.Optional(sa.Integer))
+    assert compile_type(opt_opt_int) == "Optional<Optional<Int64>>"
+
+    # Test get_ydb_type
+    ydb_type = type_compiler.get_ydb_type(opt_int, is_optional=False)
+    import ydb
+
+    assert isinstance(ydb_type, ydb.OptionalType)
+    # Int64 corresponds to PrimitiveType.Int64
+    # Note: ydb.PrimitiveType.Int64 is an enum member, but ydb_type.item is also an instance/enum?
+    # get_ydb_type returns ydb.PrimitiveType.Int64 (enum) wrapped in OptionalType.
+    # OptionalType.item is the inner type.
+    assert ydb_type.item == ydb.PrimitiveType.Int64

{ydb_sqlalchemy-0.1.14 → ydb_sqlalchemy-0.1.16}/ydb_sqlalchemy/sqlalchemy/types.py

@@ -8,7 +8,7 @@ if sa_version.startswith("2."):
 else:
     from sqlalchemy.sql.expression import ColumnElement
 
-from sqlalchemy import ARRAY, exc, types
+from sqlalchemy import ARRAY, exc, Table, types
 from sqlalchemy.sql import type_api
 
 from .datetime_types import YqlDate, YqlDateTime, YqlTimestamp, YqlDate32, YqlTimestamp64, YqlDateTime64  # noqa: F401
@@ -110,18 +110,74 @@ class Decimal(types.DECIMAL):
 class ListType(ARRAY):
     __visit_name__ = "list_type"
 
+    def bind_processor(self, dialect):
+        item_proc = self.item_type.bind_processor(dialect)
+
+        def process(value):
+            if value is None:
+                return None
+            return [item_proc(v) if v is not None else None for v in value]
+
+        if item_proc:
+            return process
+        return None
+
 
 class HashableDict(dict):
     def __hash__(self):
         return hash(tuple(self.items()))
 
 
+class Optional(types.TypeEngine):
+    """
+    Wrapper for YDB Optional type.
+
+    Used primarily within StructType to denote nullable fields.
+    """
+
+    __visit_name__ = "optional"
+
+    def __init__(self, element_type: Union[Type[types.TypeEngine], types.TypeEngine]):
+        self.element_type = element_type
+
+
 class StructType(types.TypeEngine[Mapping[str, Any]]):
+    """
+    YDB Struct type.
+
+    Represents a structured data type with named fields, mapped to a Python dictionary.
+    """
+
     __visit_name__ = "struct_type"
 
-    def __init__(self, fields_types: Mapping[str, Union[Type[types.TypeEngine], Type[types.TypeDecorator]]]):
+    def __init__(
+        self,
+        fields_types: Mapping[
+            str,
+            Union[Type[types.TypeEngine], types.TypeEngine, Optional],
+        ],
+    ):
         self.fields_types = HashableDict(dict(sorted(fields_types.items())))
 
+    @classmethod
+    def from_table(cls, table: Table) -> "StructType":
+        """
+        Create a StructType definition from a SQLAlchemy Table.
+
+        Automatically wraps nullable columns in Optional.
+
+        :param table: SQLAlchemy Table object
+        :return: StructType instance
+        """
+        fields = {}
+        for col in table.columns:
+            t = col.type
+            if col.nullable:
+                fields[col.name] = Optional(t)
+            else:
+                fields[col.name] = t
+        return cls(fields)
+
     @property
     def python_type(self):
         return dict
@@ -129,6 +185,32 @@ class StructType(types.TypeEngine[Mapping[str, Any]]):
     def compare_values(self, x, y):
         return x == y
 
+    def bind_processor(self, dialect):
+        processors = {}
+        for name, type_ in self.fields_types.items():
+            if isinstance(type_, Optional):
+                type_ = type_.element_type
+
+            type_ = type_api.to_instance(type_)
+            proc = type_.bind_processor(dialect)
+            if proc:
+                processors[name] = proc
+
+        if not processors:
+            return None
+
+        def process(value):
+            if value is None:
+                return None
+            new_value = value.copy()
+            for name, proc in processors.items():
+                if name in new_value:
+                    if new_value[name] is not None:
+                        new_value[name] = proc(new_value[name])
+            return new_value
+
+        return process
+
 
 class Lambda(ColumnElement):
     __visit_name__ = "lambda"
@@ -139,3 +221,10 @@ class Lambda(ColumnElement):
 
         self.type = type_api.NULLTYPE
         self.func = func
+
+
+class Binary(types.LargeBinary):
+    __visit_name__ = "BINARY"
+
+    def bind_processor(self, dialect):
+        return None

{ydb_sqlalchemy-0.1.14 → ydb_sqlalchemy-0.1.16/ydb_sqlalchemy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ydb-sqlalchemy
-Version: 0.1.14
+Version: 0.1.16
 Summary: YDB Dialect for SQLAlchemy
 Home-page: http://github.com/ydb-platform/ydb-sqlalchemy
 Author: Yandex LLC

ydb_sqlalchemy-0.1.14/ydb_sqlalchemy/_version.py

@@ -1 +0,0 @@
-VERSION = "0.1.14"

ydb_sqlalchemy-0.1.14/ydb_sqlalchemy/sqlalchemy/test_sqlalchemy.py

@@ -1,37 +0,0 @@
-from datetime import date
-import sqlalchemy as sa
-
-from . import YqlDialect, types
-
-
-def test_casts():
-    dialect = YqlDialect()
-    expr = sa.literal_column("1/2")
-
-    res_exprs = [
-        sa.cast(expr, types.UInt32),
-        sa.cast(expr, types.UInt64),
-        sa.cast(expr, types.UInt8),
-        sa.func.String.JoinFromList(
-            sa.func.ListMap(sa.func.TOPFREQ(expr, 5), types.Lambda(lambda x: sa.cast(x, sa.Text))),
-            ", ",
-        ),
-    ]
-
-    strs = [str(res_expr.compile(dialect=dialect, compile_kwargs={"literal_binds": True})) for res_expr in res_exprs]
-
-    assert strs == [
-        "CAST(1/2 AS UInt32)",
-        "CAST(1/2 AS UInt64)",
-        "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')"