sqlalchemy-cratedb 0.36.0__tar.gz → 0.36.1__tar.gz

{sqlalchemy_cratedb-0.36.0 → sqlalchemy_cratedb-0.36.1}/CHANGES.md

@@ -3,6 +3,9 @@
 
 ## Unreleased
 
+## 2024/06/11 0.36.1
+- Dependencies: Use `crate==1.0.0dev0`
+
 ## 2024/06/11 0.36.0
 - Dependencies: Use `dask[dataframe]`
 - Maintenance release after splitting packages `crate-python` vs.

{sqlalchemy_cratedb-0.36.0/src/sqlalchemy_cratedb.egg-info → sqlalchemy_cratedb-0.36.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-cratedb
-Version: 0.36.0
+Version: 0.36.1
 Summary: SQLAlchemy dialect for CrateDB.
 Author-email: "Crate.io" <office@crate.io>
 License: Apache License 2.0
@@ -63,7 +63,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: backports.zoneinfo<1; python_version < "3.9"
-Requires-Dist: crate
+Requires-Dist: crate==1.0.0dev0
 Requires-Dist: geojson<4,>=2.5
 Requires-Dist: importlib-resources; python_version < "3.9"
 Requires-Dist: sqlalchemy<2.1,>=1

{sqlalchemy_cratedb-0.36.0 → sqlalchemy_cratedb-0.36.1}/pyproject.toml

@@ -85,7 +85,7 @@ dynamic = [
 ]
 dependencies = [
   'backports.zoneinfo<1; python_version < "3.9"',
-  "crate",
+  "crate==1.0.0dev0",
   "geojson<4,>=2.5",
   'importlib-resources; python_version < "3.9"',
   "sqlalchemy<2.1,>=1",

{sqlalchemy_cratedb-0.36.0 → sqlalchemy_cratedb-0.36.1/src/sqlalchemy_cratedb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sqlalchemy-cratedb
-Version: 0.36.0
+Version: 0.36.1
 Summary: SQLAlchemy dialect for CrateDB.
 Author-email: "Crate.io" <office@crate.io>
 License: Apache License 2.0
@@ -63,7 +63,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: backports.zoneinfo<1; python_version < "3.9"
-Requires-Dist: crate
+Requires-Dist: crate==1.0.0dev0
 Requires-Dist: geojson<4,>=2.5
 Requires-Dist: importlib-resources; python_version < "3.9"
 Requires-Dist: sqlalchemy<2.1,>=1

sqlalchemy_cratedb-0.36.1/src/sqlalchemy_cratedb.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+CHANGES.md
+CODE_OF_CONDUCT.md
+CONTRIBUTING.md
+DEVELOP.md
+LICENSE
+MANIFEST.in
+NOTICE
+README.md
+backlog.md
+pyproject.toml
+setup.cfg
+docs/requirements.txt
+docs/_extra/robots.txt
+src/sqlalchemy_cratedb/__init__.py
+src/sqlalchemy_cratedb/compiler.py
+src/sqlalchemy_cratedb/dialect.py
+src/sqlalchemy_cratedb/predicate.py
+src/sqlalchemy_cratedb/sa_version.py
+src/sqlalchemy_cratedb/support.py
+src/sqlalchemy_cratedb.egg-info/PKG-INFO
+src/sqlalchemy_cratedb.egg-info/SOURCES.txt
+src/sqlalchemy_cratedb.egg-info/dependency_links.txt
+src/sqlalchemy_cratedb.egg-info/entry_points.txt
+src/sqlalchemy_cratedb.egg-info/requires.txt
+src/sqlalchemy_cratedb.egg-info/top_level.txt
+src/sqlalchemy_cratedb/compat/__init__.py
+src/sqlalchemy_cratedb/compat/api13.py
+src/sqlalchemy_cratedb/compat/core10.py
+src/sqlalchemy_cratedb/compat/core14.py
+src/sqlalchemy_cratedb/compat/core20.py
+src/sqlalchemy_cratedb/type/__init__.py
+src/sqlalchemy_cratedb/type/array.py
+src/sqlalchemy_cratedb/type/geo.py
+src/sqlalchemy_cratedb/type/object.py

{sqlalchemy_cratedb-0.36.0 → sqlalchemy_cratedb-0.36.1}/src/sqlalchemy_cratedb.egg-info/requires.txt

@@ -1,4 +1,4 @@
-crate
+crate==1.0.0dev0
 geojson<4,>=2.5
 sqlalchemy<2.1,>=1
 verlib2==0.2

sqlalchemy_cratedb-0.36.0/docs/.crate-docs/.build/_sources/advanced-querying.rst.txt

@@ -1,335 +0,0 @@
-.. _advanced-querying:
-
-=================
-Advanced querying
-=================
-
-This section of the documentation demonstrates running queries using a fulltext
-index with an analyzer, queries using counting and aggregations, and support for
-the ``INSERT...FROM SELECT`` and ``INSERT...RETURNING`` constructs, all using the
-CrateDB SQLAlchemy dialect.
-
-
-.. rubric:: Table of Contents
-
-.. contents::
-   :local:
-
-
-Introduction
-============
-
-Import the relevant symbols:
-
-    >>> import sqlalchemy as sa
-    >>> from sqlalchemy.orm import sessionmaker
-    >>> try:
-    ...     from sqlalchemy.orm import declarative_base
-    ... except ImportError:
-    ...     from sqlalchemy.ext.declarative import declarative_base
-    >>> from uuid import uuid4
-
-Establish a connection to the database, see also :ref:`sa:engines_toplevel`
-and :ref:`connect`:
-
-    >>> engine = sa.create_engine(f"crate://{crate_host}")
-    >>> connection = engine.connect()
-
-Create an SQLAlchemy :doc:`Session <sa:orm/session_basics>`:
-
-    >>> session = sessionmaker(bind=engine)()
-    >>> Base = declarative_base()
-
-
-Introduction to fulltext indexes
-================================
-
-:ref:`crate-reference:fulltext-indices` take the contents of one or more fields
-and split it up into tokens that are used for fulltext-search. The
-transformation from a text to separate tokens is done by an analyzer. In order
-to conduct fulltext search queries, we need to create a table with a
-:ref:`fulltext index with an analyzer <crate-reference:sql_ddl_index_fulltext>`.
-
-.. code-block:: sql
-
-    CREATE TABLE characters (
-        id STRING PRIMARY KEY,
-        name STRING,
-        quote STRING,
-        INDEX name_ft USING fulltext(name) WITH (analyzer = 'english'),
-        INDEX quote_ft USING fulltext(quote) WITH (analyzer = 'english')
-    )
-
-We have to create this table using SQL because it is currently not possible to
-create ``INDEX`` fields using SQLAlchemy's :ref:`sa:orm_declarative_mapping`.
-However, we can define the table to use all other operations:
-
-    >>> def gen_key():
-    ...     return str(uuid4())
-
-    >>> class Character(Base):
-    ...     __tablename__ = 'characters'
-    ...     id = sa.Column(sa.String, primary_key=True, default=gen_key)
-    ...     name = sa.Column(sa.String)
-    ...     quote = sa.Column(sa.String)
-    ...     name_ft = sa.Column(sa.String)
-    ...     quote_ft = sa.Column(sa.String)
-    ...     __mapper_args__ = {
-    ...         'exclude_properties': ['name_ft', 'quote_ft']
-    ...     }
-
-We define ``name_ft`` and ``quote_ft`` as regular columns, but add them under
-``__mapper_args__.exclude_properties`` to ensure they're excluded from insert
-or update operations.
-
-In order to support fulltext query operations, the CrateDB SQLAlchemy dialect
-provides the :ref:`crate-reference:predicates_match` through its ``match``
-function.
-
-Let's add two records we use for testing.
-
-    >>> arthur = Character(name='Arthur Dent')
-    >>> arthur.quote = "Let's go somewhere."
-    >>> session.add(arthur)
-
-    >>> trillian = Character(name='Tricia McMillan')
-    >>> trillian.quote = "We're on a space ship Arthur. In space."
-    >>> session.add(trillian)
-
-    >>> session.commit()
-
-After ``INSERT`` statements are submitted to the database, the newly inserted
-records aren't immediately available for retrieval, because the index is only
-updated periodically (default: each second). In order to synchronize that,
-explicitly refresh the table:
-
-    >>> _ = connection.execute(sa.text("REFRESH TABLE characters"))
-
-
-Fulltext search with MATCH predicate
-====================================
-
-Fulltext search in CrateDB is performed using :ref:`crate-reference:predicates_match`.
-The CrateDB SQLAlchemy dialect comes with a ``match`` function, which can be used to
-search on one or multiple fields.
-
-    >>> from crate.client.sqlalchemy.predicates import match
-
-    >>> session.query(Character.name) \
-    ...     .filter(match(Character.name_ft, 'Arthur')) \
-    ...     .all()
-    [('Arthur Dent',)]
-
-To get the relevance of a matching row, you can select the ``_score`` system
-column. It is a numeric value which is relative to the other rows.
-The higher the score value, the more relevant the row.
-
-In most cases, ``_score`` is not part of the SQLAlchemy table definition,
-so it must be passed as a verbatim string, using ``literal_column``:
-
-    >>> session.query(Character.name, sa.literal_column('_score')) \
-    ...     .filter(match(Character.quote_ft, 'space')) \
-    ...     .all()
-    [('Tricia McMillan', ...)]
-
-To search multiple columns, use a dictionary where the keys are the columns and
-the values are a ``boost``. A ``boost`` is a factor that increases the relevance
-of a column in respect to the other columns:
-
-    >>> session.query(Character.name) \
-    ...           .filter(match({Character.name_ft: 1.5, Character.quote_ft: 0.1},
-    ...                         'Arthur')) \
-    ...     .order_by(sa.desc(sa.literal_column('_score'))) \
-    ...     .all()
-    [('Arthur Dent',), ('Tricia McMillan',)]
-
-The ``match_type`` argument determines how a single ``query_term`` is applied,
-and how the resulting ``_score`` is computed. Thus, it influences which
-documents are considered more relevant. The default selection is ``best_fields``.
-For more information, see :ref:`crate-reference:predicates_match_types`.
-
-If you want to sort the results by ``_score``, you can use the ``order_by()``
-function.
-
-    >>> session.query(Character.name) \
-    ...     .filter(
-    ...         match(Character.name_ft, 'Arth',
-    ...                 match_type='phrase',
-    ...                 options={'fuzziness': 3})
-    ...     ) \
-    ...     .all()
-    [('Arthur Dent',)]
-
-It is not possible to specify options without the ``match_type`` argument:
-
-    >>> session.query(Character.name) \
-    ...     .filter(
-    ...         match(Character.name_ft, 'Arth',
-    ...                 options={'fuzziness': 3})
-    ...     ) \
-    ...     .all()
-    Traceback (most recent call last):
-    ValueError: missing match_type. It's not allowed to specify options without match_type
-
-
-Aggregates: Counting and grouping
-=================================
-
-SQLAlchemy supports different approaches to issue a query with a count
-aggregate function. Take a look at the `count result rows`_ documentation
-for a full overview.
-
-CrateDB currently does not support all variants as it can not handle the
-sub-queries yet.
-
-This means that queries using ``count()`` have to be written in one of the
-following ways:
-
-    >>> session.query(sa.func.count(Character.id)).scalar()
-    2
-
-    >>> session.query(sa.func.count('*')).select_from(Character).scalar()
-    2
-
-Using the ``group_by`` clause is similar:
-
-    >>> session.query(sa.func.count(Character.id), Character.name) \
-    ...     .group_by(Character.name) \
-    ...     .order_by(sa.desc(sa.func.count(Character.id))) \
-    ...     .order_by(Character.name).all()
-    [(1, 'Arthur Dent'), (1, 'Tricia McMillan')]
-
-
-``INSERT...FROM SELECT``
-========================
-
-In SQLAlchemy, the ``insert().from_select()`` function returns a new ``Insert``
-construct, which represents an ``INSERT...FROM SELECT`` statement. This
-functionality is supported by the CrateDB client library. Here is an example
-that uses ``insert().from_select()``.
-
-First, let's define and create the tables:
-
-    >>> from sqlalchemy import select, insert
-
-    >>> class Todos(Base):
-    ...     __tablename__ = 'todos'
-    ...     __table_args__ = {
-    ...         'crate_number_of_replicas': '0'
-    ...     }
-    ...     id = sa.Column(sa.String, primary_key=True, default=gen_key)
-    ...     content = sa.Column(sa.String)
-    ...     status = sa.Column(sa.String)
-
-    >>> class ArchivedTasks(Base):
-    ...     __tablename__ = 'archived_tasks'
-    ...     __table_args__ = {
-    ...         'crate_number_of_replicas': '0'
-    ...     }
-    ...     id = sa.Column(sa.String, primary_key=True)
-    ...     content = sa.Column(sa.String)
-
-    >>> Base.metadata.create_all(bind=engine)
-
-Let's add a task to the ``Todo`` table:
-
-    >>> task = Todos(content='Write Tests', status='done')
-    >>> session.add(task)
-    >>> session.commit()
-    >>> _ = connection.execute(sa.text("REFRESH TABLE todos"))
-
-Now, let's use ``insert().from_select()`` to archive the task into the
-``ArchivedTasks`` table:
-
-    >>> sel = select(Todos.id, Todos.content).where(Todos.status == "done")
-    >>> ins = insert(ArchivedTasks).from_select(['id', 'content'], sel)
-    >>> result = session.execute(ins)
-    >>> session.commit()
-
-This will emit the following ``INSERT`` statement to the database:
-
-    INSERT INTO archived_tasks (id, content)
-        (SELECT todos.id, todos.content FROM todos WHERE todos.status = 'done')
-
-Now, verify that the data is present in the database:
-
-    >>> _ = connection.execute(sa.text("REFRESH TABLE archived_tasks"))
-    >>> pprint([str(r) for r in session.execute(sa.text("SELECT content FROM archived_tasks"))])
-    ["('Write Tests',)"]
-
-
-``INSERT...RETURNING``
-======================
-
-The ``RETURNING`` clause can be used to retrieve the result rows of an ``INSERT``
-operation. It may be specified using the ``Insert.returning()`` method.
-
-The first step is to define the table:
-
-    >>> from sqlalchemy import insert
-
-    >>> class User(Base):
-    ...     __tablename__ = 'user'
-    ...     __table_args__ = {
-    ...         'crate_number_of_replicas': '0'
-    ...     }
-    ...     id = sa.Column(sa.String, primary_key=True, default=gen_key)
-    ...     username = sa.Column(sa.String)
-    ...     email = sa.Column(sa.String)
-
-    >>> Base.metadata.create_all(bind=engine)
-
-Now, let's use the returning clause on our insert to retrieve the values inserted:
-
-    >>> stmt = insert(User).values(username='Crate', email='crate@crate.io').returning(User.username, User.email)
-    >>> result = session.execute(stmt)
-    >>> session.commit()
-    >>> print([str(r) for r in result])
-    ["('Crate', 'crate@crate.io')"]
-
-The following ``INSERT...RETURNING`` statement was issued to the database::
-
-    INSERT INTO user (id, username, email)
-    VALUES (:id, :username, :email)
-    RETURNING user.id, user.username, user.email
-
-``UPDATE...RETURNING``
-
-The ``RETURNING`` clause can also be used with an ``UPDATE`` operation to return
-specified rows to be returned on execution. It can be specified using the
-``Update.returning()`` method.
-
-
-We can reuse the user table previously created in the ``INSERT...RETURNING`` section.
-
-Insert a user and get the user id:
-
-    >>> from sqlalchemy import insert, update
-
-    >>> stmt = insert(User).values(username='Arthur Dent', email='arthur_dent@crate.io').returning(User.id, User.username, User.email)
-    >>> result = session.execute(stmt)
-    >>> session.commit()
-    >>> uid = [r[0] for r in result][0]
-
-Now let's update the user:
-
-    >>> stmt = update(User).where(User.id == uid).values(username='Tricia McMillan', email='tricia_mcmillan@crate.io').returning(User.username, User.email)
-    >>> res = session.execute(stmt)
-    >>> session.commit()
-    >>> print([str(r) for r in res])
-    ["('Tricia McMillan', 'tricia_mcmillan@crate.io')"]
-
-The following ``UPDATE...RETURNING`` statement was issued to the database::
-
-    UPDATE user SET username=:username, email=:email
-    WHERE user.id = :id_1
-    RETURNING user.username, user.email
-
-.. hidden: Disconnect from database
-
-    >>> session.close()
-    >>> connection.close()
-    >>> engine.dispose()
-
-
-.. _count result rows: https://docs.sqlalchemy.org/en/14/orm/tutorial.html#counting

sqlalchemy_cratedb-0.36.0/docs/.crate-docs/.build/_sources/backlog.md.txt

@@ -1,12 +0,0 @@
-# Backlog
-
-## Iteration +1
-From dialect split-off.
-- Re-enable parameterized test cases.
-  ```
-  tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": None}))
-  tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": (4, 0, 12)}))
-  tests.addTest(ParametrizedTestCase.parametrize(SqlAlchemyCompilerTest, param={"server_version_info": (4, 1, 10)}))
-  ```
-- Re-enable doctests.
-

sqlalchemy_cratedb-0.36.0/docs/.crate-docs/.build/_sources/by-example/index.rst.txt

@@ -1,30 +0,0 @@
-.. _by-example:
-
-##########
-By example
-##########
-
-This part of the documentation enumerates different kinds of examples how to
-use the CrateDB Python client.
-
-.. _sqlalchemy-by-example:
-
-SQLAlchemy by example
-=====================
-
-The examples in this section are all about CrateDB's `SQLAlchemy`_ dialect, and
-its corresponding API interfaces, see also :ref:`sqlalchemy-support`.
-
-.. toctree::
-    :maxdepth: 1
-
-    sqlalchemy/getting-started
-    sqlalchemy/crud
-    sqlalchemy/working-with-types
-    sqlalchemy/advanced-querying
-    sqlalchemy/inspection-reflection
-    sqlalchemy/dataframe
-
-
-.. _Python DB API: https://peps.python.org/pep-0249/
-.. _SQLAlchemy: https://www.sqlalchemy.org/