databricks-sqlalchemy 0.0.1b1__tar.gz → 1.0.1__tar.gz

databricks_sqlalchemy-1.0.1/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Release History
+
+# 1.0.1 
+
+- This is databricks-sqlalchemy plugin based on sqlalchemy v1 and has all the databricks-sql-python v2.9.6 needed sqlalchemy features

databricks_sqlalchemy-1.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2022 Databricks, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

databricks_sqlalchemy-1.0.1/PKG-INFO

@@ -0,0 +1,204 @@
+Metadata-Version: 2.1
+Name: databricks-sqlalchemy
+Version: 1.0.1
+Summary: Databricks SQLAlchemy plugin for Python
+License: Apache-2.0
+Author: Databricks
+Author-email: databricks-sql-connector-maintainers@databricks.com
+Requires-Python: >=3.8.0,<4.0.0
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: databricks_sql_connector_core (>=4.0.0)
+Requires-Dist: sqlalchemy (>=1.3.24,<2.0.0)
+Project-URL: Bug Tracker, https://github.com/databricks/databricks-sqlalchemy/issues
+Project-URL: Homepage, https://github.com/databricks/databricks-sqlalchemy
+Description-Content-Type: text/markdown
+
+## Databricks dialect for SQLALchemy 1.0
+
+The Databricks dialect for SQLAlchemy serves as bridge between [SQLAlchemy](https://www.sqlalchemy.org/) and the Databricks SQL Python driver. A working example demonstrating usage can be found in `example.py`.
+
+
+## Installation
+
+To install the dialect and its dependencies:
+
+```shell
+pip install databricks-sqlalchemy~=1.0
+```
+
+If you also plan to use `alembic` you can alternatively run:
+
+```shell
+pip install alembic
+```
+
+## Connection String
+
+Every SQLAlchemy application that connects to a database needs to use an [Engine](https://docs.sqlalchemy.org/en/20/tutorial/engine.html#tutorial-engine), which you can create by passing a connection string to `create_engine`. The connection string must include these components:
+
+1. Host
+2. HTTP Path for a compute resource
+3. API access token
+4. Initial catalog for the connection
+5. Initial schema for the connection
+
+**Note: Our dialect is built and tested on workspaces with Unity Catalog enabled. Support for the `hive_metastore` catalog is untested.**
+
+For example:
+
+```python
+import os
+from sqlalchemy import create_engine
+
+host = os.getenv("DATABRICKS_SERVER_HOSTNAME")
+http_path = os.getenv("DATABRICKS_HTTP_PATH")
+access_token = os.getenv("DATABRICKS_TOKEN")
+catalog = os.getenv("DATABRICKS_CATALOG")
+schema = os.getenv("DATABRICKS_SCHEMA")
+
+if sqlalchemy.__version__.startswith("1.3"):
+	# SQLAlchemy 1.3.x fails to parse the http_path, catalog, and schema from our connection string
+	# Pass these in as connect_args instead
+
+	conn_string = f"databricks://token:{access_token}@{host}"
+	connect_args = dict(catalog=catalog, schema=schema, http_path=http_path)
+	all_connect_args = {**extra_connect_args, **connect_args}
+	engine = create_engine(conn_string, connect_args=all_connect_args)
+else:
+	engine = create_engine(
+		f"databricks://token:{access_token}@{host}?http_path={http_path}&catalog={catalog}&schema={schema}",
+		connect_args=extra_connect_args,
+	)
+
+```
+
+## Types
+
+The [SQLAlchemy type hierarchy](https://docs.sqlalchemy.org/en/13/core/type_basics.html) contains backend-agnostic type implementations (represented in CamelCase) and backend-specific types (represented in UPPERCASE). The majority of SQLAlchemy's [CamelCase](https://docs.sqlalchemy.org/en/13/core/type_basics.html#the-camelcase-datatypes) types are supported. This means that a SQLAlchemy application using these types should "just work" with Databricks.
+
+|SQLAlchemy Type|Databricks SQL Type|
+|-|-|
+[`BigInteger`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.BigInteger)| [`BIGINT`](https://docs.databricks.com/en/sql/language-manual/data-types/bigint-type.html)
+[`LargeBinary`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.LargeBinary)| (not supported)|
+[`Boolean`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Boolean)| [`BOOLEAN`](https://docs.databricks.com/en/sql/language-manual/data-types/boolean-type.html)
+[`Date`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Date)| [`DATE`](https://docs.databricks.com/en/sql/language-manual/data-types/date-type.html)
+[`DateTime`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.DateTime)| [`TIMESTAMP_NTZ`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html)|
+[`Enum`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Enum)| (not supported)|
+[`Float`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Float)| [`FLOAT`](https://docs.databricks.com/en/sql/language-manual/data-types/float-type.html)
+[`Integer`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Integer)| [`INT`](https://docs.databricks.com/en/sql/language-manual/data-types/int-type.html)
+[`Numeric`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Numeric)| [`DECIMAL`](https://docs.databricks.com/en/sql/language-manual/data-types/decimal-type.html)|
+[`PickleType`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.PickleType)| (not supported)|
+[`SmallInteger`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.SmallInteger)| [`SMALLINT`](https://docs.databricks.com/en/sql/language-manual/data-types/smallint-type.html)
+[`String`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.String)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Text`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Text)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Time`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Time)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Unicode`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Unicode)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`UnicodeText`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.UnicodeText)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Uuid`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Uuid)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)
+
+
+### `LargeBinary()` and `PickleType()`
+
+Databricks Runtime doesn't currently support binding of binary values in SQL queries, which is a pre-requisite for this functionality in SQLAlchemy.
+
+## `Enum()` and `CHECK` constraints
+
+Support for `CHECK` constraints is not implemented in this dialect. Support is planned for a future release.
+
+SQLAlchemy's `Enum()` type depends on `CHECK` constraints and is therefore not yet supported.
+
+
+### `String()`, `Text()`, `Unicode()`, and `UnicodeText()`
+
+Databricks Runtime doesn't support length limitations for `STRING` fields. Therefore `String()` or `String(1)` or `String(255)` will all produce identical DDL. Since `Text()`, `Unicode()`, `UnicodeText()` all use the same underlying type in Databricks SQL, they will generate equivalent DDL.
+
+### `Time()`
+
+Databricks Runtime doesn't have a native time-like data type. To implement this type in SQLAlchemy, our dialect stores SQLAlchemy `Time()` values in a `STRING` field. Unlike `DateTime` above, this type can optionally support timezone awareness (since the dialect is in complete control of the strings that we write to the Delta table).
+
+```python
+from sqlalchemy import Time
+
+class SomeModel(Base):
+    time_tz     = Time(timezone=True)
+    time_ntz    = Time()
+```
+
+
+# Usage Notes
+
+## `Identity()` and `autoincrement`
+
+Identity and generated value support is currently limited in this dialect.
+
+When defining models, SQLAlchemy types can accept an [`autoincrement`](https://docs.sqlalchemy.org/en/13/core/metadata.html#sqlalchemy.schema.Column.params.autoincrement) argument. In our dialect, this argument is currently ignored. To create an auto-incrementing field in your model you can pass in an explicit [`Identity()`](https://docs.sqlalchemy.org/en/13/core/defaults.html#identity-ddl) instead.
+
+Furthermore, in Databricks Runtime, only `BIGINT` fields can be configured to auto-increment. So in SQLAlchemy, you must use the `BigInteger()` type.
+
+```python
+from sqlalchemy import Identity, String
+
+class SomeModel(Base):
+    id      = BigInteger(Identity())
+    value   = String()
+```
+
+When calling `Base.metadata.create_all()`, the executed DDL will include `GENERATED ALWAYS AS IDENTITY` for the `id` column. This is useful when using SQLAlchemy to generate tables. However, as of this writing, `Identity()` constructs are not captured when SQLAlchemy reflects a table's metadata (support for this is planned).
+
+## Usage with pandas
+
+Use [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html) and [`pandas.read_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql.html#pandas.read_sql) to write and read from Databricks SQL. These methods both accept a SQLAlchemy connection to interact with Databricks.
+
+### Read from Databricks SQL into pandas
+```python
+from sqlalchemy import create_engine
+import pandas as pd
+
+engine = create_engine("databricks://token:dapi***@***.cloud.databricks.com?http_path=***&catalog=main&schema=test")
+with engine.connect() as conn:
+    # This will read the contents of `main.test.some_table`
+    df = pd.read_sql("some_table", conn)
+```
+
+### Write to Databricks SQL from pandas
+
+```python
+from sqlalchemy import create_engine
+import pandas as pd
+
+engine = create_engine("databricks://token:dapi***@***.cloud.databricks.com?http_path=***&catalog=main&schema=test")
+squares = [(i, i * i) for i in range(100)]
+df = pd.DataFrame(data=squares,columns=['x','x_squared'])
+
+with engine.connect() as conn:
+    # This will write the contents of `df` to `main.test.squares`
+    df.to_sql('squares',conn)
+```
+
+## [`PrimaryKey()`](https://docs.sqlalchemy.org/en/13/core/constraints.html#sqlalchemy.schema.PrimaryKeyConstraint) and [`ForeignKey()`](https://docs.sqlalchemy.org/en/13/core/constraints.html#defining-foreign-keys)
+
+Unity Catalog workspaces in Databricks support PRIMARY KEY and FOREIGN KEY constraints. _Note that Databricks Runtime does not enforce the integrity of FOREIGN KEY constraints_. You can establish a primary key by setting `primary_key=True` when defining a column.
+
+When building `ForeignKey` or `ForeignKeyConstraint` objects, you must specify a `name` for the constraint.
+
+If your model definition requires a self-referential FOREIGN KEY constraint, you must include `use_alter=True` when defining the relationship.
+
+```python
+from sqlalchemy import Table, Column, ForeignKey, BigInteger, String
+
+users = Table(
+    "users",
+    metadata_obj,
+    Column("id", BigInteger, primary_key=True),
+    Column("name", String(), nullable=False),
+    Column("email", String()),
+    Column("manager_id", ForeignKey("users.id", name="fk_users_manager_id_x_users_id", use_alter=True))
+)
+```
+

databricks_sqlalchemy-1.0.1/README.md

@@ -0,0 +1,182 @@
+## Databricks dialect for SQLALchemy 1.0
+
+The Databricks dialect for SQLAlchemy serves as bridge between [SQLAlchemy](https://www.sqlalchemy.org/) and the Databricks SQL Python driver. A working example demonstrating usage can be found in `example.py`.
+
+
+## Installation
+
+To install the dialect and its dependencies:
+
+```shell
+pip install databricks-sqlalchemy~=1.0
+```
+
+If you also plan to use `alembic` you can alternatively run:
+
+```shell
+pip install alembic
+```
+
+## Connection String
+
+Every SQLAlchemy application that connects to a database needs to use an [Engine](https://docs.sqlalchemy.org/en/20/tutorial/engine.html#tutorial-engine), which you can create by passing a connection string to `create_engine`. The connection string must include these components:
+
+1. Host
+2. HTTP Path for a compute resource
+3. API access token
+4. Initial catalog for the connection
+5. Initial schema for the connection
+
+**Note: Our dialect is built and tested on workspaces with Unity Catalog enabled. Support for the `hive_metastore` catalog is untested.**
+
+For example:
+
+```python
+import os
+from sqlalchemy import create_engine
+
+host = os.getenv("DATABRICKS_SERVER_HOSTNAME")
+http_path = os.getenv("DATABRICKS_HTTP_PATH")
+access_token = os.getenv("DATABRICKS_TOKEN")
+catalog = os.getenv("DATABRICKS_CATALOG")
+schema = os.getenv("DATABRICKS_SCHEMA")
+
+if sqlalchemy.__version__.startswith("1.3"):
+	# SQLAlchemy 1.3.x fails to parse the http_path, catalog, and schema from our connection string
+	# Pass these in as connect_args instead
+
+	conn_string = f"databricks://token:{access_token}@{host}"
+	connect_args = dict(catalog=catalog, schema=schema, http_path=http_path)
+	all_connect_args = {**extra_connect_args, **connect_args}
+	engine = create_engine(conn_string, connect_args=all_connect_args)
+else:
+	engine = create_engine(
+		f"databricks://token:{access_token}@{host}?http_path={http_path}&catalog={catalog}&schema={schema}",
+		connect_args=extra_connect_args,
+	)
+
+```
+
+## Types
+
+The [SQLAlchemy type hierarchy](https://docs.sqlalchemy.org/en/13/core/type_basics.html) contains backend-agnostic type implementations (represented in CamelCase) and backend-specific types (represented in UPPERCASE). The majority of SQLAlchemy's [CamelCase](https://docs.sqlalchemy.org/en/13/core/type_basics.html#the-camelcase-datatypes) types are supported. This means that a SQLAlchemy application using these types should "just work" with Databricks.
+
+|SQLAlchemy Type|Databricks SQL Type|
+|-|-|
+[`BigInteger`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.BigInteger)| [`BIGINT`](https://docs.databricks.com/en/sql/language-manual/data-types/bigint-type.html)
+[`LargeBinary`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.LargeBinary)| (not supported)|
+[`Boolean`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Boolean)| [`BOOLEAN`](https://docs.databricks.com/en/sql/language-manual/data-types/boolean-type.html)
+[`Date`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Date)| [`DATE`](https://docs.databricks.com/en/sql/language-manual/data-types/date-type.html)
+[`DateTime`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.DateTime)| [`TIMESTAMP_NTZ`](https://docs.databricks.com/en/sql/language-manual/data-types/timestamp-ntz-type.html)|
+[`Enum`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Enum)| (not supported)|
+[`Float`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Float)| [`FLOAT`](https://docs.databricks.com/en/sql/language-manual/data-types/float-type.html)
+[`Integer`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Integer)| [`INT`](https://docs.databricks.com/en/sql/language-manual/data-types/int-type.html)
+[`Numeric`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Numeric)| [`DECIMAL`](https://docs.databricks.com/en/sql/language-manual/data-types/decimal-type.html)|
+[`PickleType`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.PickleType)| (not supported)|
+[`SmallInteger`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.SmallInteger)| [`SMALLINT`](https://docs.databricks.com/en/sql/language-manual/data-types/smallint-type.html)
+[`String`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.String)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Text`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Text)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Time`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Time)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Unicode`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Unicode)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`UnicodeText`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.UnicodeText)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)|
+[`Uuid`](https://docs.sqlalchemy.org/en/13/core/type_basics.html#sqlalchemy.types.Uuid)| [`STRING`](https://docs.databricks.com/en/sql/language-manual/data-types/string-type.html)
+
+
+### `LargeBinary()` and `PickleType()`
+
+Databricks Runtime doesn't currently support binding of binary values in SQL queries, which is a pre-requisite for this functionality in SQLAlchemy.
+
+## `Enum()` and `CHECK` constraints
+
+Support for `CHECK` constraints is not implemented in this dialect. Support is planned for a future release.
+
+SQLAlchemy's `Enum()` type depends on `CHECK` constraints and is therefore not yet supported.
+
+
+### `String()`, `Text()`, `Unicode()`, and `UnicodeText()`
+
+Databricks Runtime doesn't support length limitations for `STRING` fields. Therefore `String()` or `String(1)` or `String(255)` will all produce identical DDL. Since `Text()`, `Unicode()`, `UnicodeText()` all use the same underlying type in Databricks SQL, they will generate equivalent DDL.
+
+### `Time()`
+
+Databricks Runtime doesn't have a native time-like data type. To implement this type in SQLAlchemy, our dialect stores SQLAlchemy `Time()` values in a `STRING` field. Unlike `DateTime` above, this type can optionally support timezone awareness (since the dialect is in complete control of the strings that we write to the Delta table).
+
+```python
+from sqlalchemy import Time
+
+class SomeModel(Base):
+    time_tz     = Time(timezone=True)
+    time_ntz    = Time()
+```
+
+
+# Usage Notes
+
+## `Identity()` and `autoincrement`
+
+Identity and generated value support is currently limited in this dialect.
+
+When defining models, SQLAlchemy types can accept an [`autoincrement`](https://docs.sqlalchemy.org/en/13/core/metadata.html#sqlalchemy.schema.Column.params.autoincrement) argument. In our dialect, this argument is currently ignored. To create an auto-incrementing field in your model you can pass in an explicit [`Identity()`](https://docs.sqlalchemy.org/en/13/core/defaults.html#identity-ddl) instead.
+
+Furthermore, in Databricks Runtime, only `BIGINT` fields can be configured to auto-increment. So in SQLAlchemy, you must use the `BigInteger()` type.
+
+```python
+from sqlalchemy import Identity, String
+
+class SomeModel(Base):
+    id      = BigInteger(Identity())
+    value   = String()
+```
+
+When calling `Base.metadata.create_all()`, the executed DDL will include `GENERATED ALWAYS AS IDENTITY` for the `id` column. This is useful when using SQLAlchemy to generate tables. However, as of this writing, `Identity()` constructs are not captured when SQLAlchemy reflects a table's metadata (support for this is planned).
+
+## Usage with pandas
+
+Use [`pandas.DataFrame.to_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_sql.html) and [`pandas.read_sql`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql.html#pandas.read_sql) to write and read from Databricks SQL. These methods both accept a SQLAlchemy connection to interact with Databricks.
+
+### Read from Databricks SQL into pandas
+```python
+from sqlalchemy import create_engine
+import pandas as pd
+
+engine = create_engine("databricks://token:dapi***@***.cloud.databricks.com?http_path=***&catalog=main&schema=test")
+with engine.connect() as conn:
+    # This will read the contents of `main.test.some_table`
+    df = pd.read_sql("some_table", conn)
+```
+
+### Write to Databricks SQL from pandas
+
+```python
+from sqlalchemy import create_engine
+import pandas as pd
+
+engine = create_engine("databricks://token:dapi***@***.cloud.databricks.com?http_path=***&catalog=main&schema=test")
+squares = [(i, i * i) for i in range(100)]
+df = pd.DataFrame(data=squares,columns=['x','x_squared'])
+
+with engine.connect() as conn:
+    # This will write the contents of `df` to `main.test.squares`
+    df.to_sql('squares',conn)
+```
+
+## [`PrimaryKey()`](https://docs.sqlalchemy.org/en/13/core/constraints.html#sqlalchemy.schema.PrimaryKeyConstraint) and [`ForeignKey()`](https://docs.sqlalchemy.org/en/13/core/constraints.html#defining-foreign-keys)
+
+Unity Catalog workspaces in Databricks support PRIMARY KEY and FOREIGN KEY constraints. _Note that Databricks Runtime does not enforce the integrity of FOREIGN KEY constraints_. You can establish a primary key by setting `primary_key=True` when defining a column.
+
+When building `ForeignKey` or `ForeignKeyConstraint` objects, you must specify a `name` for the constraint.
+
+If your model definition requires a self-referential FOREIGN KEY constraint, you must include `use_alter=True` when defining the relationship.
+
+```python
+from sqlalchemy import Table, Column, ForeignKey, BigInteger, String
+
+users = Table(
+    "users",
+    metadata_obj,
+    Column("id", BigInteger, primary_key=True),
+    Column("name", String(), nullable=False),
+    Column("email", String()),
+    Column("manager_id", ForeignKey("users.id", name="fk_users_manager_id_x_users_id", use_alter=True))
+)
+```

databricks_sqlalchemy-1.0.1/pyproject.toml

@@ -0,0 +1,36 @@
+[tool.poetry]
+name = "databricks-sqlalchemy"
+version = "1.0.1"
+description = "Databricks SQLAlchemy plugin for Python"
+authors = ["Databricks <databricks-sql-connector-maintainers@databricks.com>"]
+license = "Apache-2.0"
+readme = "README.md"
+packages = [{ include = "databricks", from = "src" }]
+include = ["CHANGELOG.md"]
+
+[tool.poetry.dependencies]
+python = "^3.8.0"
+databricks_sql_connector_core = { version = ">=4.0.0"}
+sqlalchemy = { version = "^1.3.24" }
+
+[tool.poetry.dev-dependencies]
+pytest = "^7.1.2"
+mypy = "^1.10.1"
+pylint = ">=2.12.0"
+black = "^22.3.0"
+pytest-dotenv = "^0.5.2"
+
+[tool.poetry.urls]
+"Homepage" = "https://github.com/databricks/databricks-sqlalchemy"
+"Bug Tracker" = "https://github.com/databricks/databricks-sqlalchemy/issues"
+
+[tool.poetry.plugins."sqlalchemy.dialects"]
+"databricks" = "databricks.sqlalchemy:DatabricksDialect"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+exclude = '/(\.eggs|\.git|\.hg|\.mypy_cache|\.nox|\.tox|\.venv|\.svn|_build|buck-out|build|dist|thrift_api)/'
+

databricks_sqlalchemy-1.0.1/src/databricks/sqlalchemy/__init__.py

@@ -0,0 +1 @@
+from databricks.sqlalchemy.dialect import DatabricksDialect

databricks_sqlalchemy-1.0.1/src/databricks/sqlalchemy/dialect/__init__.py

@@ -0,0 +1,340 @@
+"""This module's layout loosely follows example of SQLAlchemy's postgres dialect
+"""
+
+import decimal, re, datetime
+from dateutil.parser import parse
+
+import sqlalchemy
+from sqlalchemy import types, event
+from sqlalchemy.engine import default, Engine
+from sqlalchemy.exc import DatabaseError, SQLAlchemyError
+from sqlalchemy.engine import reflection
+
+from databricks import sql
+
+
+from databricks.sqlalchemy.dialect.base import (
+    DatabricksDDLCompiler,
+    DatabricksIdentifierPreparer,
+)
+from databricks.sqlalchemy.dialect.compiler import DatabricksTypeCompiler
+
+try:
+    import alembic
+except ImportError:
+    pass
+else:
+    from alembic.ddl import DefaultImpl
+
+    class DatabricksImpl(DefaultImpl):
+        __dialect__ = "databricks"
+
+
+class DatabricksDecimal(types.TypeDecorator):
+    """Translates strings to decimals"""
+
+    impl = types.DECIMAL
+
+    def process_result_value(self, value, dialect):
+        if value is not None:
+            return decimal.Decimal(value)
+        else:
+            return None
+
+
+class DatabricksTimestamp(types.TypeDecorator):
+    """Translates timestamp strings to datetime objects"""
+
+    impl = types.TIMESTAMP
+
+    def process_result_value(self, value, dialect):
+        return value
+
+    def adapt(self, impltype, **kwargs):
+        return self.impl
+
+
+class DatabricksDate(types.TypeDecorator):
+    """Translates date strings to date objects"""
+
+    impl = types.DATE
+
+    def process_result_value(self, value, dialect):
+        return value
+
+    def adapt(self, impltype, **kwargs):
+        return self.impl
+
+
+class DatabricksDialect(default.DefaultDialect):
+    """This dialect implements only those methods required to pass our e2e tests"""
+
+    # Possible attributes are defined here: https://docs.sqlalchemy.org/en/14/core/internals.html#sqlalchemy.engine.Dialect
+    name: str = "databricks"
+    driver: str = "databricks-sql-python"
+    default_schema_name: str = "default"
+
+    preparer = DatabricksIdentifierPreparer  # type: ignore
+    type_compiler = DatabricksTypeCompiler
+    ddl_compiler = DatabricksDDLCompiler
+    supports_statement_cache: bool = True
+    supports_multivalues_insert: bool = True
+    supports_native_decimal: bool = True
+    supports_sane_rowcount: bool = False
+    non_native_boolean_check_constraint: bool = False
+
+    @classmethod
+    def dbapi(cls):
+        return sql
+
+    def create_connect_args(self, url):
+        # TODO: can schema be provided after HOST?
+        # Expected URI format is: databricks+thrift://token:dapi***@***.cloud.databricks.com?http_path=/sql/***
+
+        kwargs = {
+            "server_hostname": url.host,
+            "access_token": url.password,
+            "http_path": url.query.get("http_path"),
+            "catalog": url.query.get("catalog"),
+            "schema": url.query.get("schema"),
+        }
+
+        self.schema = kwargs["schema"]
+        self.catalog = kwargs["catalog"]
+
+        return [], kwargs
+
+    def get_columns(self, connection, table_name, schema=None, **kwargs):
+        """Return information about columns in `table_name`.
+
+        Given a :class:`_engine.Connection`, a string
+        `table_name`, and an optional string `schema`, return column
+        information as a list of dictionaries with these keys:
+
+        name
+          the column's name
+
+        type
+          [sqlalchemy.types#TypeEngine]
+
+        nullable
+          boolean
+
+        default
+          the column's default value
+
+        autoincrement
+          boolean
+
+        sequence
+          a dictionary of the form
+              {'name' : str, 'start' :int, 'increment': int, 'minvalue': int,
+               'maxvalue': int, 'nominvalue': bool, 'nomaxvalue': bool,
+               'cycle': bool, 'cache': int, 'order': bool}
+
+        Additional column attributes may be present.
+        """
+
+        _type_map = {
+            "boolean": types.Boolean,
+            "smallint": types.SmallInteger,
+            "int": types.Integer,
+            "bigint": types.BigInteger,
+            "float": types.Float,
+            "double": types.Float,
+            "string": types.String,
+            "varchar": types.String,
+            "char": types.String,
+            "binary": types.String,
+            "array": types.String,
+            "map": types.String,
+            "struct": types.String,
+            "uniontype": types.String,
+            "decimal": DatabricksDecimal,
+            "timestamp": DatabricksTimestamp,
+            "date": DatabricksDate,
+        }
+
+        with self.get_connection_cursor(connection) as cur:
+            resp = cur.columns(
+                catalog_name=self.catalog,
+                schema_name=schema or self.schema,
+                table_name=table_name,
+            ).fetchall()
+
+        columns = []
+
+        for col in resp:
+
+            # Taken from PyHive. This removes added type info from decimals and maps
+            _col_type = re.search(r"^\w+", col.TYPE_NAME).group(0)
+            this_column = {
+                "name": col.COLUMN_NAME,
+                "type": _type_map[_col_type.lower()],
+                "nullable": bool(col.NULLABLE),
+                "default": col.COLUMN_DEF,
+                "autoincrement": False if col.IS_AUTO_INCREMENT == "NO" else True,
+            }
+            columns.append(this_column)
+
+        return columns
+
+    def get_pk_constraint(self, connection, table_name, schema=None, **kw):
+        """Return information about the primary key constraint on
+        table_name`.
+
+        Given a :class:`_engine.Connection`, a string
+        `table_name`, and an optional string `schema`, return primary
+        key information as a dictionary with these keys:
+
+        constrained_columns
+          a list of column names that make up the primary key
+
+        name
+          optional name of the primary key constraint.
+
+        """
+        # TODO: implement this behaviour
+        return {"constrained_columns": []}
+
+    def get_foreign_keys(self, connection, table_name, schema=None, **kw):
+        """Return information about foreign_keys in `table_name`.
+
+        Given a :class:`_engine.Connection`, a string
+        `table_name`, and an optional string `schema`, return foreign
+        key information as a list of dicts with these keys:
+
+        name
+          the constraint's name
+
+        constrained_columns
+          a list of column names that make up the foreign key
+
+        referred_schema
+          the name of the referred schema
+
+        referred_table
+          the name of the referred table
+
+        referred_columns
+          a list of column names in the referred table that correspond to
+          constrained_columns
+        """
+        # TODO: Implement this behaviour
+        return []
+
+    def get_indexes(self, connection, table_name, schema=None, **kw):
+        """Return information about indexes in `table_name`.
+
+        Given a :class:`_engine.Connection`, a string
+        `table_name` and an optional string `schema`, return index
+        information as a list of dictionaries with these keys:
+
+        name
+          the index's name
+
+        column_names
+          list of column names in order
+
+        unique
+          boolean
+        """
+        # TODO: Implement this behaviour
+        return []
+
+    def get_table_names(self, connection, schema=None, **kwargs):
+        TABLE_NAME = 1
+        with self.get_connection_cursor(connection) as cur:
+            sql_str = "SHOW TABLES FROM {}".format(
+                ".".join([self.catalog, schema or self.schema])
+            )
+            data = cur.execute(sql_str).fetchall()
+            _tables = [i[TABLE_NAME] for i in data]
+
+        return _tables
+
+    def get_view_names(self, connection, schema=None, **kwargs):
+        VIEW_NAME = 1
+        with self.get_connection_cursor(connection) as cur:
+            sql_str = "SHOW VIEWS FROM {}".format(
+                ".".join([self.catalog, schema or self.schema])
+            )
+            data = cur.execute(sql_str).fetchall()
+            _tables = [i[VIEW_NAME] for i in data]
+
+        return _tables
+
+    def do_rollback(self, dbapi_connection):
+        # Databricks SQL Does not support transactions
+        pass
+
+    def has_table(
+        self, connection, table_name, schema=None, catalog=None, **kwargs
+    ) -> bool:
+        """SQLAlchemy docstrings say dialect providers must implement this method"""
+
+        _schema = schema or self.schema
+        _catalog = catalog or self.catalog
+
+        # DBR >12.x uses underscores in error messages
+        DBR_LTE_12_NOT_FOUND_STRING = "Table or view not found"
+        DBR_GT_12_NOT_FOUND_STRING = "TABLE_OR_VIEW_NOT_FOUND"
+
+        try:
+            res = connection.execute(
+                f"DESCRIBE TABLE {_catalog}.{_schema}.{table_name}"
+            )
+            return True
+        except DatabaseError as e:
+            if DBR_GT_12_NOT_FOUND_STRING in str(
+                e
+            ) or DBR_LTE_12_NOT_FOUND_STRING in str(e):
+                return False
+            else:
+                raise e
+
+    def get_connection_cursor(self, connection):
+        """Added for backwards compatibility with 1.3.x"""
+        if hasattr(connection, "_dbapi_connection"):
+            return connection._dbapi_connection.dbapi_connection.cursor()
+        elif hasattr(connection, "raw_connection"):
+            return connection.raw_connection().cursor()
+        elif hasattr(connection, "connection"):
+            return connection.connection.cursor()
+
+        raise SQLAlchemyError(
+            "Databricks dialect can't obtain a cursor context manager from the dbapi"
+        )
+
+    @reflection.cache
+    def get_schema_names(self, connection, **kw):
+        # Equivalent to SHOW DATABASES
+
+        # TODO: replace with call to cursor.schemas() once its performance matches raw SQL
+        return [row[0] for row in connection.execute("SHOW SCHEMAS")]
+
+
+@event.listens_for(Engine, "do_connect")
+def receive_do_connect(dialect, conn_rec, cargs, cparams):
+    """Helpful for DS on traffic from clients using SQLAlchemy in particular"""
+
+    # Ignore connect invocations that don't use our dialect
+    if not dialect.name == "databricks":
+        return
+
+    if "_user_agent_entry" in cparams:
+        new_user_agent = f"sqlalchemy + {cparams['_user_agent_entry']}"
+    else:
+        new_user_agent = "sqlalchemy"
+
+    cparams["_user_agent_entry"] = new_user_agent
+
+    if sqlalchemy.__version__.startswith("1.3"):
+        # SQLAlchemy 1.3.x fails to parse the http_path, catalog, and schema from our connection string
+        # These should be passed in as connect_args when building the Engine
+
+        if "schema" in cparams:
+            dialect.schema = cparams["schema"]
+
+        if "catalog" in cparams:
+            dialect.catalog = cparams["catalog"]

databricks_sqlalchemy-1.0.1/src/databricks/sqlalchemy/dialect/base.py

@@ -0,0 +1,17 @@
+import re
+from sqlalchemy.sql import compiler
+
+
+class DatabricksIdentifierPreparer(compiler.IdentifierPreparer):
+    # SparkSQL identifier specification:
+    # ref: https://spark.apache.org/docs/latest/sql-ref-identifier.html
+
+    legal_characters = re.compile(r"^[A-Z0-9_]+$", re.I)
+
+    def __init__(self, dialect):
+        super().__init__(dialect, initial_quote="`")
+
+
+class DatabricksDDLCompiler(compiler.DDLCompiler):
+    def post_create_table(self, table):
+        return " USING DELTA"

databricks_sqlalchemy-1.0.1/src/databricks/sqlalchemy/dialect/compiler.py

@@ -0,0 +1,38 @@
+from sqlalchemy.sql import compiler
+
+
+class DatabricksTypeCompiler(compiler.GenericTypeCompiler):
+    """Originally forked from pyhive"""
+
+    def visit_INTEGER(self, type_):
+        return "INT"
+
+    def visit_NUMERIC(self, type_):
+        return "DECIMAL"
+
+    def visit_CHAR(self, type_):
+        return "STRING"
+
+    def visit_VARCHAR(self, type_):
+        return "STRING"
+
+    def visit_NCHAR(self, type_):
+        return "STRING"
+
+    def visit_TEXT(self, type_):
+        return "STRING"
+
+    def visit_CLOB(self, type_):
+        return "STRING"
+
+    def visit_BLOB(self, type_):
+        return "BINARY"
+
+    def visit_TIME(self, type_):
+        return "TIMESTAMP"
+
+    def visit_DATE(self, type_):
+        return "DATE"
+
+    def visit_DATETIME(self, type_):
+        return "TIMESTAMP"

databricks_sqlalchemy-0.0.1b1/PKG-INFO

@@ -1,19 +0,0 @@
-Metadata-Version: 2.1
-Name: databricks-sqlalchemy
-Version: 0.0.1b1
-Summary: SQLAlchemy dialect for Databricks
-License: Apache-2.0
-Author: Databricks
-Author-email: databricks-sql-connector-maintainers@databricks.com
-Requires-Python: >=3.8.0,<4.0.0
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Description-Content-Type: text/markdown
-
-# SQLAlchemy Dialect for Databricks
-
-To install the SQLAlchemy dialect for Databricks, see [here](https://github.com/databricks/databricks-sql-python/blob/main/src/databricks/sqlalchemy/README.sqlalchemy.md).

databricks_sqlalchemy-0.0.1b1/README.md

@@ -1,3 +0,0 @@
-# SQLAlchemy Dialect for Databricks
-
-To install the SQLAlchemy dialect for Databricks, see [here](https://github.com/databricks/databricks-sql-python/blob/main/src/databricks/sqlalchemy/README.sqlalchemy.md).

databricks_sqlalchemy-0.0.1b1/databricks/__init__.py

@@ -1,7 +0,0 @@
-# See: https://packaging.python.org/guides/packaging-namespace-packages/#pkgutil-style-namespace-packages
-#
-# This file must only contain the following line, or other packages in the databricks.* namespace
-# may not be importable. The contents of this file must be byte-for-byte equivalent across all packages.
-# If they are not, parallel package installation may lead to clobbered and invalid files.
-# Also see https://github.com/databricks/databricks-sdk-py/issues/343.
-__path__ = __import__("pkgutil").extend_path(__path__, __name__)

databricks_sqlalchemy-0.0.1b1/databricks/sqlalchemy/__init__.py

@@ -1,2 +0,0 @@
-def hello() -> str:
-    return "world"

databricks_sqlalchemy-0.0.1b1/pyproject.toml

@@ -1,16 +0,0 @@
-[tool.poetry]
-name = "databricks-sqlalchemy"
-version = "0.0.1b1"
-description = "SQLAlchemy dialect for Databricks"
-authors = ["Databricks <databricks-sql-connector-maintainers@databricks.com>"]
-license = "Apache-2.0"
-readme = "README.md"
-packages = [{include = "databricks"}]
-
-[tool.poetry.dependencies]
-python = "^3.8.0"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"