datacontract-cli 0.10.3__py3-none-any.whl → 0.10.5__py3-none-any.whl

datacontract/breaking/breaking.py

@@ -257,6 +257,18 @@ def field_breaking_changes(
             )
             continue
 
+        if field_definition_field == "items" and old_field.type == "array" and new_field.type == "array":
+            results.extend(
+                field_breaking_changes(
+                    old_field=old_value,
+                    new_field=new_value,
+                    composition=composition + ["items"],
+                    new_path=new_path,
+                    include_severities=include_severities,
+                )
+            )
+            continue
+
         rule_name = None
         description = None
 

datacontract/breaking/breaking_rules.py

@@ -90,6 +90,10 @@ class BreakingRules:
     field_tags_removed = Severity.INFO
     field_tags_updated = Severity.INFO
 
+    field_example_added = Severity.INFO
+    field_example_updated = Severity.INFO
+    field_example_removed = Severity.INFO
+
     # quality Rules
     quality_added = Severity.INFO
     quality_removed = Severity.WARNING

datacontract/catalog/catalog.py

@@ -7,8 +7,7 @@ from jinja2 import PackageLoader, Environment, select_autoescape
 
 from datacontract.data_contract import DataContract
 from datacontract.export.html_export import get_version
-from datacontract.model.data_contract_specification import \
-    DataContractSpecification
+from datacontract.model.data_contract_specification import DataContractSpecification
 
 
 def create_data_contract_html(contracts, file: Path, path: Path):
@@ -71,6 +70,7 @@ def create_index_html(contracts, path):
             datacontract_cli_version=datacontract_cli_version,
             contracts=contracts,
             contracts_size=len(contracts),
+            owners=sorted(set(dc.spec.info.owner for dc in contracts if dc.spec.info.owner)),
         )
         f.write(html_string)
     print(f"Created {index_filepath}")

datacontract/cli.py

@@ -2,6 +2,7 @@ from enum import Enum
 from importlib import metadata
 from pathlib import Path
 from typing import Iterable, Optional
+from typing import List
 
 import typer
 from click import Context
@@ -11,11 +12,10 @@ from rich.table import Table
 from typer.core import TyperGroup
 from typing_extensions import Annotated
 
-from datacontract.catalog.catalog import create_index_html, \
-    create_data_contract_html
+from datacontract.catalog.catalog import create_index_html, create_data_contract_html
 from datacontract.data_contract import DataContract
-from datacontract.init.download_datacontract_file import \
-    download_datacontract_file, FileExistsException
+from datacontract.init.download_datacontract_file import download_datacontract_file, FileExistsException
+from datacontract.publish.publish import publish_to_datamesh_manager
 
 console = Console()
 
@@ -158,12 +158,20 @@ class ExportFormat(str, Enum):
     sql = "sql"
     sql_query = "sql-query"
     html = "html"
+    go = "go"
+    bigquery = "bigquery"
+    dbml = "dbml"
 
 
 @app.command()
 def export(
     format: Annotated[ExportFormat, typer.Option(help="The export format.")],
-    output: Annotated[Path, typer.Option(help="Specify the file path where the exported data will be saved. If no path is provided, the output will be printed to stdout.")] = None,
+    output: Annotated[
+        Path,
+        typer.Option(
+            help="Specify the file path where the exported data will be saved. If no path is provided, the output will be printed to stdout."
+        ),
+    ] = None,
     server: Annotated[str, typer.Option(help="The server name to export.")] = None,
     model: Annotated[
         str,
@@ -204,7 +212,7 @@ def export(
     if output is None:
         console.print(result, markup=False)
     else:
-        with output.open('w') as f:
+        with output.open("w") as f:
             f.write(result)
         console.print(f"Written result to {output}")
 
@@ -213,20 +221,46 @@ class ImportFormat(str, Enum):
     sql = "sql"
     avro = "avro"
     glue = "glue"
+    bigquery = "bigquery"
+    jsonschema = "jsonschema"
 
 
 @app.command(name="import")
 def import_(
     format: Annotated[ImportFormat, typer.Option(help="The format of the source file.")],
-    source: Annotated[str, typer.Option(help="The path to the file or Glue Database that should be imported.")],
+    source: Annotated[
+        Optional[str], typer.Option(help="The path to the file or Glue Database that should be imported.")
+    ] = None,
+    bigquery_project: Annotated[Optional[str], typer.Option(help="The bigquery project id.")] = None,
+    bigquery_dataset: Annotated[Optional[str], typer.Option(help="The bigquery dataset id.")] = None,
+    bigquery_table: Annotated[
+        Optional[List[str]],
+        typer.Option(
+            help="List of table ids to import from the bigquery API (repeat for multiple table ids, leave empty for all tables in the dataset)."
+        ),
+    ] = None,
 ):
     """
     Create a data contract from the given source location. Prints to stdout.
     """
-    result = DataContract().import_from_source(format, source)
+    result = DataContract().import_from_source(format, source, bigquery_table, bigquery_project, bigquery_dataset)
     console.print(result.to_yaml())
 
 
+@app.command(name="publish")
+def publish(
+    location: Annotated[
+        str, typer.Argument(help="The location (url or path) of the data contract yaml.")
+    ] = "datacontract.yaml",
+):
+    """
+    Publish the data contract to the Data Mesh Manager.
+    """
+    publish_to_datamesh_manager(
+        data_contract=DataContract(data_contract_file=location),
+    )
+
+
 @app.command(name="catalog")
 def catalog(
     files: Annotated[

datacontract/data_contract.py

@@ -6,20 +6,19 @@ import typing
 import yaml
 from pyspark.sql import SparkSession
 
-from datacontract.breaking.breaking import models_breaking_changes, \
-    quality_breaking_changes
+from datacontract.breaking.breaking import models_breaking_changes, quality_breaking_changes
 from datacontract.engines.datacontract.check_that_datacontract_contains_valid_servers_configuration import (
     check_that_datacontract_contains_valid_server_configuration,
 )
-from datacontract.engines.fastjsonschema.check_jsonschema import \
-    check_jsonschema
+from datacontract.engines.fastjsonschema.check_jsonschema import check_jsonschema
 from datacontract.engines.soda.check_soda_execute import check_soda_execute
 from datacontract.export.avro_converter import to_avro_schema_json
 from datacontract.export.avro_idl_converter import to_avro_idl
-from datacontract.export.dbt_converter import to_dbt_models_yaml, \
-    to_dbt_sources_yaml, to_dbt_staging_sql
-from datacontract.export.great_expectations_converter import \
-    to_great_expectations
+from datacontract.export.bigquery_converter import to_bigquery_json
+from datacontract.export.dbml_converter import to_dbml_diagram
+from datacontract.export.dbt_converter import to_dbt_models_yaml, to_dbt_sources_yaml, to_dbt_staging_sql
+from datacontract.export.go_converter import to_go_types
+from datacontract.export.great_expectations_converter import to_great_expectations
 from datacontract.export.html_export import to_html
 from datacontract.export.jsonschema_converter import to_jsonschema_json
 from datacontract.export.odcs_converter import to_odcs_yaml
@@ -30,26 +29,22 @@ from datacontract.export.sodacl_converter import to_sodacl_yaml
 from datacontract.export.sql_converter import to_sql_ddl, to_sql_query
 from datacontract.export.terraform_converter import to_terraform
 from datacontract.imports.avro_importer import import_avro
+from datacontract.imports.bigquery_importer import import_bigquery_from_api, import_bigquery_from_json
 from datacontract.imports.glue_importer import import_glue
+from datacontract.imports.jsonschema_importer import import_jsonschema
 from datacontract.imports.sql_importer import import_sql
-from datacontract.integration.publish_datamesh_manager import \
-    publish_datamesh_manager
+from datacontract.integration.publish_datamesh_manager import publish_datamesh_manager
 from datacontract.integration.publish_opentelemetry import publish_opentelemetry
 from datacontract.lint import resolve
 from datacontract.lint.linters.description_linter import DescriptionLinter
 from datacontract.lint.linters.example_model_linter import ExampleModelLinter
 from datacontract.lint.linters.field_pattern_linter import FieldPatternLinter
-from datacontract.lint.linters.field_reference_linter import \
-    FieldReferenceLinter
+from datacontract.lint.linters.field_reference_linter import FieldReferenceLinter
 from datacontract.lint.linters.notice_period_linter import NoticePeriodLinter
-from datacontract.lint.linters.quality_schema_linter import \
-    QualityUsesSchemaLinter
-from datacontract.lint.linters.valid_constraints_linter import \
-    ValidFieldConstraintsLinter
-from datacontract.model.breaking_change import BreakingChanges, BreakingChange, \
-    Severity
-from datacontract.model.data_contract_specification import \
-    DataContractSpecification, Server
+from datacontract.lint.linters.quality_schema_linter import QualityUsesSchemaLinter
+from datacontract.lint.linters.valid_constraints_linter import ValidFieldConstraintsLinter
+from datacontract.model.breaking_change import BreakingChanges, BreakingChange, Severity
+from datacontract.model.data_contract_specification import DataContractSpecification, Server
 from datacontract.model.exceptions import DataContractException
 from datacontract.model.run import Run, Check
 
@@ -289,28 +284,8 @@ class DataContract:
             inline_quality=True,
         )
         if export_format == "jsonschema":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_jsonschema_json(model_name, model_value)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_jsonschema_json(model_name, model_value)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_jsonschema_json(model_name, model_value)
         if export_format == "sodacl":
             return to_sodacl_yaml(data_contract)
         if export_format == "dbt":
@@ -318,28 +293,8 @@ class DataContract:
         if export_format == "dbt-sources":
             return to_dbt_sources_yaml(data_contract, self._server)
         if export_format == "dbt-staging-sql":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_dbt_staging_sql(data_contract, model_name, model_value)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_dbt_staging_sql(data_contract, model_name, model_value)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_dbt_staging_sql(data_contract, model_name, model_value)
         if export_format == "odcs":
             return to_odcs_yaml(data_contract)
         if export_format == "rdf":
@@ -347,28 +302,8 @@ class DataContract:
         if export_format == "protobuf":
             return to_protobuf(data_contract)
         if export_format == "avro":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_avro_schema_json(model_name, model_value)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_avro_schema_json(model_name, model_value)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_avro_schema_json(model_name, model_value)
         if export_format == "avro-idl":
             return to_avro_idl(data_contract)
         if export_format == "terraform":
@@ -377,59 +312,33 @@ class DataContract:
             server_type = self._determine_sql_server_type(data_contract, sql_server_type)
             return to_sql_ddl(data_contract, server_type=server_type)
         if export_format == "sql-query":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
             server_type = self._determine_sql_server_type(data_contract, sql_server_type)
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_sql_query(data_contract, model_name, model_value, server_type)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. Available models: {model_names}"
-                    )
-
-                return to_sql_query(data_contract, model_name, model_value, server_type)
-
+            return to_sql_query(data_contract, model_name, model_value, server_type)
         if export_format == "great-expectations":
-            if data_contract.models is None:
-                raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
-
-            model_names = list(data_contract.models.keys())
-
-            if model == "all":
-                if len(data_contract.models.items()) != 1:
-                    raise RuntimeError(
-                        f"Export to {export_format} is model specific. Specify the model via --model "
-                        f"$MODEL_NAME. Available models: {model_names}"
-                    )
-
-                model_name, model_value = next(iter(data_contract.models.items()))
-                return to_great_expectations(data_contract, model_name)
-            else:
-                model_name = model
-                model_value = data_contract.models.get(model_name)
-                if model_value is None:
-                    raise RuntimeError(
-                        f"Model {model_name} not found in the data contract. " f"Available models: {model_names}"
-                    )
-
-                return to_great_expectations(data_contract, model_name)
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            return to_great_expectations(data_contract, model_name)
         if export_format == "pydantic-model":
             return to_pydantic_model_str(data_contract)
         if export_format == "html":
             return to_html(data_contract)
+        if export_format == "go":
+            return to_go_types(data_contract)
+        if export_format == "bigquery":
+            model_name, model_value = self._check_models_for_export(data_contract, model, export_format)
+            found_server = data_contract.servers.get(self._server)
+            if found_server is None:
+                raise RuntimeError(
+                    f"Export to {export_format} requires selecting a bigquery server from the data contract."
+                )
+            if found_server.type != "bigquery":
+                raise RuntimeError(
+                    f"Export to {export_format} requires selecting a bigquery server from the data contract."
+                )
+            return to_bigquery_json(model_name, model_value, found_server)
+        if export_format == "dbml":
+            found_server = data_contract.servers.get(self._server)
+            return to_dbml_diagram(data_contract, found_server)
         else:
             print(f"Export format {export_format} not supported.")
             return ""
@@ -484,7 +393,39 @@ class DataContract:
         run.log_info(f"Using {server} for testing the examples")
         return server
 
-    def import_from_source(self, format: str, source: str) -> DataContractSpecification:
+    def _check_models_for_export(
+        self, data_contract: DataContractSpecification, model: str, export_format: str
+    ) -> typing.Tuple[str, str]:
+        if data_contract.models is None:
+            raise RuntimeError(f"Export to {export_format} requires models in the data contract.")
+
+        model_names = list(data_contract.models.keys())
+
+        if model == "all":
+            if len(data_contract.models.items()) != 1:
+                raise RuntimeError(
+                    f"Export to {export_format} is model specific. Specify the model via --model $MODEL_NAME. Available models: {model_names}"
+                )
+
+            model_name, model_value = next(iter(data_contract.models.items()))
+        else:
+            model_name = model
+            model_value = data_contract.models.get(model_name)
+            if model_value is None:
+                raise RuntimeError(
+                    f"Model {model_name} not found in the data contract. Available models: {model_names}"
+                )
+
+        return model_name, model_value
+
+    def import_from_source(
+        self,
+        format: str,
+        source: typing.Optional[str] = None,
+        bigquery_tables: typing.Optional[typing.List[str]] = None,
+        bigquery_project: typing.Optional[str] = None,
+        bigquery_dataset: typing.Optional[str] = None,
+    ) -> DataContractSpecification:
         data_contract_specification = DataContract.init()
 
         if format == "sql":
@@ -493,6 +434,15 @@ class DataContract:
             data_contract_specification = import_avro(data_contract_specification, source)
         elif format == "glue":
             data_contract_specification = import_glue(data_contract_specification, source)
+        elif format == "jsonschema":
+            data_contract_specification = import_jsonschema(data_contract_specification, source)
+        elif format == "bigquery":
+            if source is not None:
+                data_contract_specification = import_bigquery_from_json(data_contract_specification, source)
+            else:
+                data_contract_specification = import_bigquery_from_api(
+                    data_contract_specification, bigquery_tables, bigquery_project, bigquery_dataset
+                )
         else:
             print(f"Import format {format} not supported.")
 

datacontract/engines/soda/check_soda_execute.py

@@ -9,6 +9,7 @@ from datacontract.engines.soda.connections.duckdb import get_duckdb_connection
 from datacontract.engines.soda.connections.kafka import create_spark_session, read_kafka_topic
 from datacontract.engines.soda.connections.postgres import to_postgres_soda_configuration
 from datacontract.engines.soda.connections.snowflake import to_snowflake_soda_configuration
+from datacontract.engines.soda.connections.sqlserver import to_sqlserver_soda_configuration
 from datacontract.export.sodacl_converter import to_sodacl_yaml
 from datacontract.model.data_contract_specification import DataContractSpecification, Server
 from datacontract.model.run import Run, Check, Log
@@ -69,6 +70,10 @@ def check_soda_execute(
         read_kafka_topic(spark, data_contract, server, tmp_dir)
         scan.add_spark_session(spark, data_source_name=server.type)
         scan.set_data_source_name(server.type)
+    elif server.type == "sqlserver":
+        soda_configuration_str = to_sqlserver_soda_configuration(server)
+        scan.add_configuration_yaml_str(soda_configuration_str)
+        scan.set_data_source_name(server.type)
 
     else:
         run.checks.append(

datacontract/engines/soda/connections/duckdb.py

@@ -87,8 +87,7 @@ def setup_s3_connection(con, server):
         s3_endpoint = server.endpointUrl.removeprefix("http://").removeprefix("https://")
         if server.endpointUrl.startswith("http://"):
             use_ssl = "false"
-            url_style = 'path'
-
+            url_style = "path"
 
     if s3_access_key_id is not None:
         con.sql(f"""

datacontract/engines/soda/connections/sqlserver.py

@@ -0,0 +1,43 @@
+import os
+
+import yaml
+
+from datacontract.model.data_contract_specification import Server
+
+
+def to_sqlserver_soda_configuration(server: Server) -> str:
+    """Serialize server config to soda configuration.
+
+
+    ### Example:
+        type: sqlserver
+        host: host
+        port: '1433'
+        username: simple
+        password: simple_pass
+        database: database
+        schema: dbo
+        trusted_connection: false
+        encrypt: false
+        trust_server_certificate: false
+        driver: ODBC Driver 18 for SQL Server
+    """
+    # with service account key, using an external json file
+    soda_configuration = {
+        f"data_source {server.type}": {
+            "type": "sqlserver",
+            "host": server.host,
+            "port": str(server.port),
+            "username": os.getenv("DATACONTRACT_SQLSERVER_USERNAME", ""),
+            "password": os.getenv("DATACONTRACT_SQLSERVER_PASSWORD", ""),
+            "database": server.database,
+            "schema": server.schema_,
+            "trusted_connection": os.getenv("DATACONTRACT_SQLSERVER_TRUSTED_CONNECTION", False),
+            "trust_server_certificate": os.getenv("DATACONTRACT_SQLSERVER_TRUST_SERVER_CERTIFICATE", False),
+            "encrypt": os.getenv("DATACONTRACT_SQLSERVER_ENCRYPTED_CONNECTION", True),
+            "driver": server.driver,
+        }
+    }
+
+    soda_configuration_str = yaml.dump(soda_configuration)
+    return soda_configuration_str

datacontract/export/avro_converter.py

@@ -34,6 +34,16 @@ def to_avro_field(field, field_name):
     if field.description is not None:
         avro_field["doc"] = field.description
     avro_field["type"] = to_avro_type(field, field_name)
+    # add logical type definitions for any of the date type fields
+    if field.type in ["timestamp", "timestamp_tz", "timestamp_ntz", "date"]:
+        avro_field["logicalType"] = to_avro_logical_type(field.type)
+
+    if field.config:
+        if "avroLogicalType" in field.config:
+            avro_field["logicalType"] = field.config["avroLogicalType"]
+        if "avroDefault" in field.config:
+            avro_field["default"] = field.config["avroDefault"]
+
     return avro_field
 
 
@@ -54,9 +64,9 @@ def to_avro_type(field: Field, field_name: str) -> str | dict:
     elif field.type in ["boolean"]:
         return "boolean"
     elif field.type in ["timestamp", "timestamp_tz"]:
-        return "string"
+        return "long"
     elif field.type in ["timestamp_ntz"]:
-        return "string"
+        return "long"
     elif field.type in ["date"]:
         return "int"
     elif field.type in ["time"]:
@@ -72,3 +82,14 @@ def to_avro_type(field: Field, field_name: str) -> str | dict:
         return "null"
     else:
         return "bytes"
+
+
+def to_avro_logical_type(type: str) -> str:
+    if type in ["timestamp", "timestamp_tz"]:
+        return "timestamp-millis"
+    elif type in ["timestamp_ntz"]:
+        return "local-timestamp-millis"
+    elif type in ["date"]:
+        return "date"
+    else:
+        return ""

datacontract/export/bigquery_converter.py

@@ -0,0 +1,107 @@
+import json
+import logging
+from typing import Dict, List
+
+from datacontract.model.data_contract_specification import Model, Field, Server
+from datacontract.model.exceptions import DataContractException
+
+
+def to_bigquery_json(model_name: str, model_value: Model, server: Server) -> str:
+    bigquery_table = to_bigquery_schema(model_name, model_value, server)
+    return json.dumps(bigquery_table, indent=2)
+
+
+def to_bigquery_schema(model_name: str, model_value: Model, server: Server) -> dict:
+    return {
+        "kind": "bigquery#table",
+        "tableReference": {"datasetId": server.dataset, "projectId": server.project, "tableId": model_name},
+        "description": model_value.description,
+        "schema": {"fields": to_fields_array(model_value.fields)},
+    }
+
+
+def to_fields_array(fields: Dict[str, Field]) -> List[Dict[str, Field]]:
+    bq_fields = []
+    for field_name, field in fields.items():
+        bq_fields.append(to_field(field_name, field))
+
+    return bq_fields
+
+
+def to_field(field_name: str, field: Field) -> dict:
+    bq_type = map_type_to_bigquery(field.type, field_name)
+    bq_field = {
+        "name": field_name,
+        "type": bq_type,
+        "mode": "REQUIRED" if field.required else "NULLABLE",
+        "description": field.description,
+    }
+
+    # handle arrays
+    if field.type == "array":
+        bq_field["mode"] = "REPEATED"
+        if field.items.type == "object":
+            # in case the array type is a complex object, we want to copy all its fields
+            bq_field["fields"] = to_fields_array(field.items.fields)
+        else:
+            # otherwise we make up a structure that gets us a single field of the specified type
+            bq_field["fields"] = to_fields_array(
+                {f"{field_name}_1": Field(type=field.items.type, required=False, description="")}
+            )
+    # all of these can carry other fields
+    elif bq_type.lower() in ["record", "struct"]:
+        bq_field["fields"] = to_fields_array(field.fields)
+
+    # strings can have a maxlength
+    if bq_type.lower() == "string":
+        bq_field["maxLength"] = field.maxLength
+
+    # number types have precision and scale
+    if bq_type.lower() in ["numeric", "bignumeric"]:
+        bq_field["precision"] = field.precision
+        bq_field["scale"] = field.scale
+
+    return bq_field
+
+
+def map_type_to_bigquery(type_str: str, field_name: str) -> str:
+    logger = logging.getLogger(__name__)
+    if type_str.lower() in ["string", "varchar", "text"]:
+        return "STRING"
+    elif type_str == "bytes":
+        return "BYTES"
+    elif type_str.lower() in ["int", "integer"]:
+        return "INTEGER"
+    elif type_str.lower() in ["long", "bigint"]:
+        return "INT64"
+    elif type_str == "float":
+        return "FLOAT"
+    elif type_str == "boolean":
+        return "BOOL"
+    elif type_str.lower() in ["timestamp", "timestamp_tz"]:
+        return "TIMESTAMP"
+    elif type_str == "date":
+        return "DATE"
+    elif type_str == "timestamp_ntz":
+        return "TIME"
+    elif type_str.lower() in ["number", "decimal", "numeric"]:
+        return "NUMERIC"
+    elif type_str == "double":
+        return "BIGNUMERIC"
+    elif type_str.lower() in ["object", "record", "array"]:
+        return "RECORD"
+    elif type_str == "struct":
+        return "STRUCT"
+    elif type_str == "null":
+        logger.info(
+            f"Can't properly map {field_name} to bigquery Schema, as 'null' is not supported as a type. Mapping it to STRING."
+        )
+        return "STRING"
+    else:
+        raise DataContractException(
+            type="schema",
+            result="failed",
+            name="Map datacontract type to bigquery data type",
+            reason=f"Unsupported type {type_str} in data contract definition.",
+            engine="datacontract",
+        )