def __init__(self,
name="default",
data_context=None,
data_asset_type=None,
credentials=None,
batch_kwargs_generators=None,
**kwargs):
if not sqlalchemy:
raise DatasourceInitializationError(
name, "ModuleNotFoundError: No module named 'sqlalchemy'")
configuration_with_defaults = SqlAlchemyDatasource.build_configuration(
data_asset_type, batch_kwargs_generators, **kwargs)
data_asset_type = configuration_with_defaults.pop("data_asset_type")
batch_kwargs_generators = configuration_with_defaults.pop(
"batch_kwargs_generators", None)
super(SqlAlchemyDatasource,
self).__init__(name,
data_context=data_context,
data_asset_type=data_asset_type,
batch_kwargs_generators=batch_kwargs_generators,
**configuration_with_defaults)
if credentials is not None:
self._datasource_config.update({"credentials": credentials})
else:
credentials = {}
try:
# if an engine was provided, use that
if "engine" in kwargs:
self.engine = kwargs.pop("engine")
# if a connection string or url was provided, use that
elif "connection_string" in kwargs:
connection_string = kwargs.pop("connection_string")
self.engine = create_engine(connection_string, **kwargs)
self.engine.connect()
elif "url" in credentials:
url = credentials.pop("url")
# TODO perhaps we could carefully regex out the driver from the
# url. It would need to be cautious to avoid leaking secrets.
self.drivername = "other"
self.engine = create_engine(url, **kwargs)
self.engine.connect()
# Otherwise, connect using remaining kwargs
else:
options, drivername = self._get_sqlalchemy_connection_options(
**kwargs)
self.drivername = drivername
self.engine = create_engine(options)
self.engine.connect()
except (sqlalchemy.exc.OperationalError,
sqlalchemy.exc.DatabaseError) as sqlalchemy_error:
raise DatasourceInitializationError(self._name,
str(sqlalchemy_error))
self._build_generators()
def __init__(self,
name="default",
data_context=None,
data_asset_type=None,
profile=None,
generators=None,
**kwargs):
if not sqlalchemy:
raise DatasourceInitializationError(
name, "ModuleNotFoundError: No module named 'sqlalchemy'")
if generators is None:
generators = {"default": {"type": "queries"}}
if data_asset_type is None:
data_asset_type = ClassConfig(class_name="SqlAlchemyDataset")
else:
try:
data_asset_type = ClassConfig(**data_asset_type)
except TypeError:
# In this case, we allow the passed config, for now, in case they're using a legacy string-only config
pass
super(SqlAlchemyDatasource,
self).__init__(name,
type_="sqlalchemy",
data_context=data_context,
data_asset_type=data_asset_type,
generators=generators)
if profile is not None:
self._datasource_config.update({"profile": profile})
try:
# if an engine was provided, use that
if "engine" in kwargs:
self.engine = kwargs.pop("engine")
# if a connection string or url was provided, use that
elif "connection_string" in kwargs:
connection_string = kwargs.pop("connection_string")
self.engine = create_engine(connection_string, **kwargs)
self.engine.connect()
elif "url" in kwargs:
url = kwargs.pop("url")
self.engine = create_engine(url, **kwargs)
self.engine.connect()
# Otherwise, connect using remaining kwargs
else:
self.engine = create_engine(
self._get_sqlalchemy_connection_options(**kwargs))
self.engine.connect()
except sqlalchemy.exc.OperationalError as sqlalchemy_error:
raise DatasourceInitializationError(self._name,
str(sqlalchemy_error))
self._build_generators()
def __init__(self,
name="default",
data_context=None,
data_asset_type=None,
credentials=None,
generators=None,
**kwargs):
if not sqlalchemy:
raise DatasourceInitializationError(
name, "ModuleNotFoundError: No module named 'sqlalchemy'")
configuration_with_defaults = SqlAlchemyDatasource.build_configuration(
data_asset_type, generators, **kwargs)
data_asset_type = configuration_with_defaults.pop("data_asset_type")
generators = configuration_with_defaults.pop("generators")
super(SqlAlchemyDatasource,
self).__init__(name,
data_context=data_context,
data_asset_type=data_asset_type,
generators=generators,
**configuration_with_defaults)
if credentials is not None:
self._datasource_config.update({"credentials": credentials})
else:
credentials = {}
try:
# if an engine was provided, use that
if "engine" in kwargs:
self.engine = kwargs.pop("engine")
# if a connection string or url was provided, use that
elif "connection_string" in kwargs:
connection_string = kwargs.pop("connection_string")
self.engine = create_engine(connection_string, **kwargs)
self.engine.connect()
elif "url" in credentials:
url = credentials.pop("url")
self.engine = create_engine(url, **kwargs)
self.engine.connect()
# Otherwise, connect using remaining kwargs
else:
self.engine = create_engine(
self._get_sqlalchemy_connection_options(**kwargs))
self.engine.connect()
except sqlalchemy.exc.OperationalError as sqlalchemy_error:
raise DatasourceInitializationError(self._name,
str(sqlalchemy_error))
self._build_generators()
def __init__(self,
name="default",
data_context=None,
data_asset_type=None,
credentials=None,
batch_kwargs_generators=None,
**kwargs):
if not sqlalchemy:
raise DatasourceInitializationError(
name, "ModuleNotFoundError: No module named 'sqlalchemy'")
configuration_with_defaults = SqlAlchemyDatasource.build_configuration(
data_asset_type, batch_kwargs_generators, **kwargs)
data_asset_type = configuration_with_defaults.pop("data_asset_type")
batch_kwargs_generators = configuration_with_defaults.pop(
"batch_kwargs_generators", None)
super().__init__(name,
data_context=data_context,
data_asset_type=data_asset_type,
batch_kwargs_generators=batch_kwargs_generators,
**configuration_with_defaults)
if credentials is not None:
self._datasource_config.update({"credentials": credentials})
else:
credentials = {}
try:
# if an engine was provided, use that
if "engine" in kwargs:
self.engine = kwargs.pop("engine")
# if a connection string or url was provided, use that
elif "connection_string" in kwargs:
connection_string = kwargs.pop("connection_string")
self.engine = create_engine(connection_string, **kwargs)
connection = self.engine.connect()
connection.close()
elif "url" in credentials:
url = credentials.pop("url")
self.drivername = urlparse(url).scheme
self.engine = create_engine(url, **kwargs)
connection = self.engine.connect()
connection.close()
# Otherwise, connect using remaining kwargs
else:
(
options,
create_engine_kwargs,
drivername,
) = self._get_sqlalchemy_connection_options(**kwargs)
self.drivername = drivername
self.engine = create_engine(options, **create_engine_kwargs)
connection = self.engine.connect()
connection.close()
# since we switched to lazy loading of Datasources when we initialise a DataContext,
# the dialect of SQLAlchemy Datasources cannot be obtained reliably when we send
# "data_context.__init__" events.
# This event fills in the SQLAlchemy dialect.
if data_context is not None and getattr(
data_context, "_usage_statistics_handler", None):
handler = data_context._usage_statistics_handler
handler.send_usage_message(
event="datasource.sqlalchemy.connect",
event_payload={
"anonymized_name":
handler._datasource_anonymizer.anonymize(self.name),
"sqlalchemy_dialect":
self.engine.name,
},
success=True,
)
except datasource_initialization_exceptions as sqlalchemy_error:
raise DatasourceInitializationError(self._name,
str(sqlalchemy_error))
self._build_generators()