diff --git a/deploy_ai_search/README.md b/deploy_ai_search/README.md index 775bf6b..c67858f 100644 --- a/deploy_ai_search/README.md +++ b/deploy_ai_search/README.md @@ -15,13 +15,13 @@ The associated scripts in this portion of the repository contains pre-built scri ## Steps for Text2SQL Index Deployment -### Entity Schema Index +### Schema Store Index 1. Update `.env` file with the associated values. Not all values are required dependent on whether you are using System / User Assigned Identities or a Key based authentication. -2. Adjust `text_2_sql.py` with any changes to the index / indexer. The `get_skills()` method implements the skills pipeline. Make any adjustments here in the skills needed to enrich the data source. +2. Adjust `text_2_sql_schema_store.py` with any changes to the index / indexer. The `get_skills()` method implements the skills pipeline. Make any adjustments here in the skills needed to enrich the data source. 3. Run `deploy.py` with the following args: - - `index_type text_2_sql`. This selects the `Text2SQLAISearch` sub class. + - `index_type text_2_sql_schema_store`. This selects the `Text2SQLSchemaStoreAISearch` sub class. - `rebuild`. Whether to delete and rebuild the index. - `suffix`. Optional parameter that will apply a suffix onto the deployed index and indexer. This is useful if you want deploy a test version, before overwriting the main version. - `single_data_dictionary`. Optional parameter that controls whether you will be uploading a single data dictionary, or a data dictionary file per entity. By default, this is set to False. diff --git a/deploy_ai_search/ai_search.py b/deploy_ai_search/ai_search.py index 2e8bf12..6d63bac 100644 --- a/deploy_ai_search/ai_search.py +++ b/deploy_ai_search/ai_search.py @@ -48,7 +48,8 @@ def __init__( """ if not hasattr(self, "indexer_type"): - self.indexer_type = None # Needed to help mypy understand that indexer_type is defined in the child class + # Needed to help mypy understand that indexer_type is defined in the child class + self.indexer_type = None raise ValueError("indexer_type is not defined in the child class.") if rebuild is not None: @@ -126,13 +127,14 @@ def get_index_fields(self) -> list[SearchableField]: Returns: list[SearchableField]: The index fields""" - @abstractmethod def get_semantic_search(self) -> SemanticSearch: """Get the semantic search configuration for the indexer. Returns: SemanticSearch: The semantic search configuration""" + return None + def get_skills(self) -> list: """Get the skillset for the indexer. diff --git a/deploy_ai_search/deploy.py b/deploy_ai_search/deploy.py index cbfe042..5ff2483 100644 --- a/deploy_ai_search/deploy.py +++ b/deploy_ai_search/deploy.py @@ -2,7 +2,7 @@ # Licensed under the MIT License. import argparse from rag_documents import RagDocumentsAISearch -from text_2_sql import Text2SqlAISearch +from text_2_sql_schema_store import Text2SqlSchemaStoreAISearch from text_2_sql_query_cache import Text2SqlQueryCacheAISearch import logging @@ -20,8 +20,8 @@ def deploy_config(arguments: argparse.Namespace): rebuild=arguments.rebuild, enable_page_by_chunking=arguments.enable_page_chunking, ) - elif arguments.index_type == "text_2_sql": - index_config = Text2SqlAISearch( + elif arguments.index_type == "text_2_sql_schema_store": + index_config = Text2SqlSchemaStoreAISearch( suffix=arguments.suffix, rebuild=arguments.rebuild, single_data_dictionary=arguments.single_data_dictionary, diff --git a/deploy_ai_search/environment.py b/deploy_ai_search/environment.py index a47bf1c..e431304 100644 --- a/deploy_ai_search/environment.py +++ b/deploy_ai_search/environment.py @@ -12,7 +12,7 @@ class IndexerType(Enum): """The type of the indexer""" RAG_DOCUMENTS = "rag-documents" - TEXT_2_SQL = "text-2-sql" + TEXT_2_SQL_SCHEMA_STORE = "text-2-sql-schema-store" TEXT_2_SQL_QUERY_CACHE = "text-2-sql-query-cache" diff --git a/deploy_ai_search/rag_documents.py b/deploy_ai_search/rag_documents.py index c514a0d..c9ebffd 100644 --- a/deploy_ai_search/rag_documents.py +++ b/deploy_ai_search/rag_documents.py @@ -281,7 +281,7 @@ def get_indexer(self) -> SearchIndexer: indexer_parameters = IndexingParameters( batch_size=batch_size, configuration=IndexingParametersConfiguration( - data_to_extract=BlobIndexerDataToExtract.ALL_METADATA, + data_to_extract=BlobIndexerDataToExtract.STORAGE_METADATA, query_timeout=None, execution_environment=execution_environment, fail_on_unprocessable_document=False, diff --git a/deploy_ai_search/text_2_sql_query_cache.py b/deploy_ai_search/text_2_sql_query_cache.py index 61dd24d..18296c6 100644 --- a/deploy_ai_search/text_2_sql_query_cache.py +++ b/deploy_ai_search/text_2_sql_query_cache.py @@ -5,10 +5,6 @@ SearchFieldDataType, SearchField, SearchableField, - SemanticField, - SemanticPrioritizedFields, - SemanticConfiguration, - SemanticSearch, SimpleField, ComplexField, ) @@ -52,42 +48,52 @@ def get_index_fields(self) -> list[SearchableField]: vector_search_dimensions=self.environment.open_ai_embedding_dimensions, vector_search_profile_name=self.vector_search_profile_name, ), - SearchableField( - name="Query", type=SearchFieldDataType.String, filterable=True - ), ComplexField( - name="Schemas", + name="SqlQueryDecomposition", collection=True, fields=[ SearchableField( - name="Entity", + name="SqlQuery", type=SearchFieldDataType.String, filterable=True, ), ComplexField( - name="Columns", + name="Schemas", collection=True, fields=[ SearchableField( - name="Name", type=SearchFieldDataType.String - ), - SearchableField( - name="Definition", type=SearchFieldDataType.String - ), - SearchableField( - name="Type", type=SearchFieldDataType.String - ), - SearchableField( - name="AllowedValues", + name="Entity", type=SearchFieldDataType.String, - collection=True, - searchable=False, + filterable=True, ), - SearchableField( - name="SampleValues", - type=SearchFieldDataType.String, + ComplexField( + name="Columns", collection=True, - searchable=False, + fields=[ + SearchableField( + name="Name", + type=SearchFieldDataType.String, + ), + SearchableField( + name="Definition", + type=SearchFieldDataType.String, + ), + SearchableField( + name="DataType", type=SearchFieldDataType.String + ), + SearchableField( + name="AllowedValues", + type=SearchFieldDataType.String, + collection=True, + searchable=False, + ), + SearchableField( + name="SampleValues", + type=SearchFieldDataType.String, + collection=True, + searchable=False, + ), + ], ), ], ), @@ -101,23 +107,3 @@ def get_index_fields(self) -> list[SearchableField]: ] return fields - - def get_semantic_search(self) -> SemanticSearch: - """This function returns the semantic search configuration for sql index - - Returns: - SemanticSearch: The semantic search configuration""" - - semantic_config = SemanticConfiguration( - name=self.semantic_config_name, - prioritized_fields=SemanticPrioritizedFields( - title_field=SemanticField(field_name="Question"), - keywords_fields=[ - SemanticField(field_name="Query"), - ], - ), - ) - - semantic_search = SemanticSearch(configurations=[semantic_config]) - - return semantic_search diff --git a/deploy_ai_search/text_2_sql.py b/deploy_ai_search/text_2_sql_schema_store.py similarity index 70% rename from deploy_ai_search/text_2_sql.py rename to deploy_ai_search/text_2_sql_schema_store.py index 3310039..c8c91de 100644 --- a/deploy_ai_search/text_2_sql.py +++ b/deploy_ai_search/text_2_sql_schema_store.py @@ -26,7 +26,7 @@ ) -class Text2SqlAISearch(AISearch): +class Text2SqlSchemaStoreAISearch(AISearch): """This class is used to deploy the sql index.""" def __init__( @@ -41,7 +41,7 @@ def __init__( suffix (str, optional): The suffix for the indexer. Defaults to None. If an suffix is provided, it is assumed to be a test indexer. rebuild (bool, optional): Whether to rebuild the index. Defaults to False. """ - self.indexer_type = IndexerType.TEXT_2_SQL + self.indexer_type = IndexerType.TEXT_2_SQL_SCHEMA_STORE super().__init__(suffix, rebuild) if single_data_dictionary: @@ -62,26 +62,35 @@ def get_index_fields(self) -> list[SearchableField]: key=True, analyzer_name="keyword", ), + SearchableField( + name="EntityName", type=SearchFieldDataType.String, filterable=True + ), SearchableField( name="Entity", type=SearchFieldDataType.String, analyzer_name="keyword", ), SearchableField( - name="EntityName", type=SearchFieldDataType.String, filterable=True + name="Database", + type=SearchFieldDataType.String, ), SearchableField( - name="Description", + name="Warehouse", + type=SearchFieldDataType.String, + ), + SearchableField( + name="Definition", type=SearchFieldDataType.String, sortable=False, filterable=False, facetable=False, ), SearchField( - name="DescriptionEmbedding", + name="DefinitionEmbedding", type=SearchFieldDataType.Collection(SearchFieldDataType.Single), vector_search_dimensions=self.environment.open_ai_embedding_dimensions, vector_search_profile_name=self.vector_search_profile_name, + hidden=True, ), ComplexField( name="Columns", @@ -89,7 +98,7 @@ def get_index_fields(self) -> list[SearchableField]: fields=[ SearchableField(name="Name", type=SearchFieldDataType.String), SearchableField(name="Definition", type=SearchFieldDataType.String), - SearchableField(name="Type", type=SearchFieldDataType.String), + SearchableField(name="DataType", type=SearchFieldDataType.String), SearchableField( name="AllowedValues", type=SearchFieldDataType.String, @@ -102,6 +111,11 @@ def get_index_fields(self) -> list[SearchableField]: collection=True, searchable=False, ), + SearchableField( + name="JoinableEntities", + type=SearchFieldDataType.String, + collection=True, + ), ], ), SearchableField( @@ -111,6 +125,40 @@ def get_index_fields(self) -> list[SearchableField]: hidden=True, # This is needed to enable semantic searching against the column names as complex field types are not used. ), + SearchableField( + name="ColumnDefinitions", + type=SearchFieldDataType.String, + collection=True, + hidden=True, + # This is needed to enable semantic searching against the column names as complex field types are not used. + ), + ComplexField( + name="EntityRelationships", + collection=True, + fields=[ + SearchableField( + name="ForeignEntity", + type=SearchFieldDataType.String, + ), + ComplexField( + name="ForeignKeys", + collection=True, + fields=[ + SearchableField( + name="Column", type=SearchFieldDataType.String + ), + SearchableField( + name="ForeignColumn", type=SearchFieldDataType.String + ), + ], + ), + ], + ), + SearchableField( + name="CompleteEntityRelationshipsGraph", + type=SearchFieldDataType.String, + collection=True, + ), SimpleField( name="DateLastModified", type=SearchFieldDataType.DateTimeOffset, @@ -131,7 +179,8 @@ def get_semantic_search(self) -> SemanticSearch: prioritized_fields=SemanticPrioritizedFields( title_field=SemanticField(field_name="EntityName"), content_fields=[ - SemanticField(field_name="Description"), + SemanticField(field_name="Definition"), + SemanticField(field_name="ColumnDefinitions"), ], keywords_fields=[ SemanticField(field_name="ColumnNames"), @@ -151,7 +200,7 @@ def get_skills(self) -> list: list: The skillsets used in the indexer""" embedding_skill = self.get_vector_skill( - "/document", "/document/Description", target_name="DescriptionEmbedding" + "/document", "/document/Definition", target_name="DefinitionEmbedding" ) skills = [embedding_skill] @@ -222,12 +271,20 @@ def get_indexer(self) -> SearchIndexer: target_field_name="EntityName", ), FieldMapping( - source_field_name="/document/Description", - target_field_name="Description", + source_field_name="/document/Database", + target_field_name="Database", ), FieldMapping( - source_field_name="/document/DescriptionEmbedding", - target_field_name="DescriptionEmbedding", + source_field_name="/document/Warehouse", + target_field_name="Warehouse", + ), + FieldMapping( + source_field_name="/document/Definition", + target_field_name="Definition", + ), + FieldMapping( + source_field_name="/document/DefinitionEmbedding", + target_field_name="DefinitionEmbedding", ), FieldMapping( source_field_name="/document/Columns", @@ -237,6 +294,18 @@ def get_indexer(self) -> SearchIndexer: source_field_name="/document/Columns/*/Name", target_field_name="ColumnNames", ), + FieldMapping( + source_field_name="/document/Columns/*/Definition", + target_field_name="ColumnDefinitions", + ), + FieldMapping( + source_field_name="/document/EntityRelationships", + target_field_name="EntityRelationships", + ), + FieldMapping( + source_field_name="/document/CompleteEntityRelationshipsGraph/*", + target_field_name="CompleteEntityRelationshipsGraph", + ), FieldMapping( source_field_name="/document/DateLastModified", target_field_name="DateLastModified", diff --git a/text_2_sql/data_dictionary/.env b/text_2_sql/data_dictionary/.env index 39fdcb3..4ecd14c 100644 --- a/text_2_sql/data_dictionary/.env +++ b/text_2_sql/data_dictionary/.env @@ -4,17 +4,7 @@ OpenAI__Endpoint= OpenAI__ApiKey= OpenAI__ApiVersion= Text2Sql__DatabaseEngine= -Text2Sql__UseQueryCache= -Text2Sql__PreRunQueryCache= Text2Sql__DatabaseName= Text2Sql__DatabaseConnectionString= -AIService__AzureSearchOptions__Endpoint= -AIService__AzureSearchOptions__Key= -AIService__AzureSearchOptions__RagDocuments__Index= -AIService__AzureSearchOptions__Text2Sql__Index= -AIService__AzureSearchOptions__Text2SqlQueryCache__Index= -AIService__AzureSearchOptions__RagDocuments__SemanticConfig= -AIService__AzureSearchOptions__Text2Sql__SemanticConfig= -AIService__AzureSearchOptions__Text2SqlQueryCache__SemanticConfig= IdentityType= # system_assigned or user_assigned or key ClientId= diff --git a/text_2_sql/data_dictionary/data_dictionary_creator.py b/text_2_sql/data_dictionary/data_dictionary_creator.py index f9b897d..8de5e9e 100644 --- a/text_2_sql/data_dictionary/data_dictionary_creator.py +++ b/text_2_sql/data_dictionary/data_dictionary_creator.py @@ -14,15 +14,86 @@ from azure.identity import DefaultAzureCredential, get_bearer_token_provider import random import re +import networkx as nx logging.basicConfig(level=logging.INFO) +class ForeignKeyRelationship(BaseModel): + column: str = Field(..., alias="Column") + foreign_column: str = Field(..., alias="ForeignColumn") + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + +class EntityRelationship(BaseModel): + entity: str = Field(..., alias="Entity", exclude=True) + entity_schema: str = Field(..., alias="Schema", exclude=True) + foreign_entity: str = Field(..., alias="ForeignEntity") + foreign_entity_schema: str = Field(..., alias="ForeignSchema", exclude=True) + foreign_keys: list[ForeignKeyRelationship] = Field(..., alias="ForeignKeys") + + model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True) + + def pivot(self): + """A method to pivot the entity relationship.""" + return EntityRelationship( + entity=self.foreign_entity, + entity_schema=self.foreign_entity_schema, + foreign_entity=self.entity, + foreign_entity_schema=self.entity_schema, + foreign_keys=[ + ForeignKeyRelationship( + column=foreign_key.foreign_column, + foreign_column=foreign_key.column, + ) + for foreign_key in self.foreign_keys + ], + ) + + def add_foreign_key(self, foreign_key: ForeignKeyRelationship): + """A method to add a foreign key to the entity relationship.""" + + for existing_foreign_key in self.foreign_keys: + if ( + existing_foreign_key.column == foreign_key.column + and existing_foreign_key.foreign_column == foreign_key.foreign_column + ): + return + + self.foreign_keys.append(foreign_key) + + @classmethod + def from_sql_row(cls, row, columns): + """A method to create an EntityRelationship from a SQL row.""" + result = dict(zip(columns, row)) + + entity = "{EntitySchema}.{Entity}".format( + EntitySchema=result["EntitySchema"], Entity=result["Entity"] + ) + foreign_entity = "{ForeignEntitySchema}.{ForeignEntity}".format( + ForeignEntitySchema=result["ForeignEntitySchema"], + ForeignEntity=result["ForeignEntity"], + ) + return cls( + entity=entity, + entity_schema=result["EntitySchema"], + foreign_entity=foreign_entity, + foreign_entity_schema=result["ForeignEntitySchema"], + foreign_keys=[ + ForeignKeyRelationship( + column=result["Column"], + foreign_column=result["ForeignColumn"], + ) + ], + ) + + class ColumnItem(BaseModel): """A class to represent a column item.""" name: str = Field(..., alias="Name") - type: str = Field(..., alias="Type") + data_type: str = Field(..., alias="DataType") definition: Optional[str] = Field(..., alias="Definition") distinct_values: Optional[list[any]] = Field( None, alias="DistinctValues", exclude=True @@ -37,7 +108,9 @@ def from_sql_row(cls, row, columns): """A method to create a ColumnItem from a SQL row.""" result = dict(zip(columns, row)) return cls( - name=result["Name"], type=result["Type"], definition=result["Definition"] + name=result["Name"], + data_type=result["DataType"], + definition=result["Definition"], ) @@ -45,10 +118,20 @@ class EntityItem(BaseModel): """A class to represent an entity item.""" entity: str = Field(..., alias="Entity") - description: Optional[str] = Field(..., alias="Description") + definition: Optional[str] = Field(..., alias="Definition") name: str = Field(..., alias="Name", exclude=True) entity_schema: str = Field(..., alias="Schema", exclude=True) entity_name: Optional[str] = Field(default=None, alias="EntityName") + database: Optional[str] = Field(default=None, alias="Database") + warehouse: Optional[str] = Field(default=None, alias="Warehouse") + + entity_relationships: Optional[list[EntityRelationship]] = Field( + alias="EntityRelationships", default_factory=list + ) + + complete_entity_relationships_graph: Optional[list[str]] = Field( + alias="CompleteEntityRelationshipsGraph", default_factory=list + ) columns: Optional[list[ColumnItem]] = Field( ..., alias="Columns", default_factory=list @@ -67,7 +150,7 @@ def from_sql_row(cls, row, columns): entity=entity, name=result["Entity"], entity_schema=result["EntitySchema"], - description=result["Description"], + definition=result["Definition"], ) @@ -79,7 +162,7 @@ def __init__( entities: list[str] = None, excluded_entities: list[str] = None, single_file: bool = False, - generate_descriptions: bool = True, + generate_definitions: bool = True, ): """A method to initialize the DataDictionaryCreator class. @@ -87,13 +170,19 @@ def __init__( entities (list[str], optional): A list of entities to extract. Defaults to None. If None, all entities are extracted. excluded_entities (list[str], optional): A list of entities to exclude. Defaults to None. single_file (bool, optional): A flag to indicate if the data dictionary should be saved to a single file. Defaults to False. - generate_descriptions (bool, optional): A flag to indicate if descriptions should be generated. Defaults to True. + generate_definitions (bool, optional): A flag to indicate if definitions should be generated. Defaults to True. """ self.entities = entities self.excluded_entities = excluded_entities self.single_file = single_file - self.generate_descriptions = generate_descriptions + self.generate_definitions = generate_definitions + + self.entity_relationships = {} + self.relationship_graph = nx.DiGraph() + + self.warehouse = None + self.database = None load_dotenv(find_dotenv()) @@ -102,20 +191,28 @@ def __init__( def extract_table_entities_sql_query(self) -> str: """An abstract property to extract table entities from a database. - Must return 3 columns: Entity, EntitySchema, Description.""" + Must return 3 columns: Entity, EntitySchema, Definition.""" @property @abstractmethod def extract_view_entities_sql_query(self) -> str: """An abstract property to extract view entities from a database. - Must return 3 columns: Entity, EntitySchema, Description.""" + Must return 3 columns: Entity, EntitySchema, Definition.""" @abstractmethod def extract_columns_sql_query(self, entity: EntityItem) -> str: """An abstract method to extract column information from a database. - Must return 3 columns: Name, Type, Definition.""" + Must return 3 columns: Name, DataType, Definition.""" + + @property + @abstractmethod + def extract_entity_relationships_sql_query(self) -> str: + """An abstract method to extract entity relationships from a database. + + Must return 6 columns: EntitySchema, Entity, ForeignEntitySchema, ForeignEntity, Column, ForeignColumn. + """ def extract_distinct_values_sql_query( self, entity: EntityItem, column: ColumnItem @@ -163,8 +260,103 @@ async def query_entities( return results - async def extract_entities_with_descriptions(self) -> list[EntityItem]: - """A method to extract entities with descriptions from a database. + async def extract_entity_relationships(self) -> list[EntityRelationship]: + """A method to extract entity relationships from a database. + + Returns: + list[EntityRelationships]: The list of entity relationships.""" + + relationships = await self.query_entities( + self.extract_entity_relationships_sql_query, cast_to=EntityRelationship + ) + + # Duplicate relationships to create a complete graph + + for relationship in relationships: + if relationship.entity not in self.entity_relationships: + self.entity_relationships[relationship.entity] = { + relationship.foreign_entity: relationship + } + else: + if ( + relationship.foreign_entity + not in self.entity_relationships[relationship.entity] + ): + self.entity_relationships[relationship.entity][ + relationship.foreign_entity + ] = relationship + + self.entity_relationships[relationship.entity][ + relationship.foreign_entity + ].add_foreign_key(relationship.foreign_keys[0]) + + if relationship.foreign_entity not in self.entity_relationships: + self.entity_relationships[relationship.foreign_entity] = { + relationship.entity: relationship.pivot() + } + else: + if ( + relationship.entity + not in self.entity_relationships[relationship.foreign_entity] + ): + self.entity_relationships[relationship.foreign_entity][ + relationship.entity + ] = relationship.pivot() + + self.entity_relationships[relationship.foreign_entity][ + relationship.entity + ].add_foreign_key(relationship.pivot().foreign_keys[0]) + + async def build_entity_relationship_graph(self) -> nx.DiGraph: + """A method to build a complete entity relationship graph.""" + + for entity, foreign_entities in self.entity_relationships.items(): + for foreign_entity, relationship in foreign_entities.items(): + self.relationship_graph.add_edge( + entity, foreign_entity, relationship=relationship + ) + + def get_entity_relationships_from_graph( + self, entity: str, path=None, result=None, visited=None + ) -> nx.DiGraph: + if entity not in self.relationship_graph: + return [] + + if path is None: + path = [entity] + if result is None: + result = [] + if visited is None: + visited = set() + + # Mark the current node as visited + visited.add(entity) + + successors = list(self.relationship_graph.successors(entity)) + successors_not_visited = [ + successor for successor in successors if successor not in visited + ] + + if len(path) == 1 and entity in successors: + # We can do a self join on the entity in this case but we don't want to propagate this + result.append(f"{entity} -> {entity}") + + if len(successors_not_visited) == 0 and len(path) > 1: + # Add the complete path to the result as a string + result.append(" -> ".join(path)) + else: + # For each successor (neighbor in the directed path) + for successor in successors_not_visited: + new_path = path + [successor] + # Add the path as a string + self.get_entity_relationships_from_graph( + successor, new_path, result, visited.copy() + ) + + return result + + async def extract_entities_with_definitions(self) -> list[EntityItem]: + """A method to extract entities with definitions from a database. Returns: list[EntityItem]: The list of entities.""" @@ -191,6 +383,11 @@ async def extract_entities_with_descriptions(self) -> list[EntityItem]: if entity.entity not in self.excluded_entities ] + # Add warehouse and database to entities + for entity in all_entities: + entity.warehouse = self.warehouse + entity.database = self.database + return all_entities async def extract_column_distinct_values( @@ -228,47 +425,48 @@ async def extract_column_distinct_values( elif column.distinct_values is not None: column.sample_values = column.distinct_values - async def generate_column_description(self, entity: EntityItem, column: ColumnItem): - """A method to generate a description for a column in a database. + async def generate_column_definition(self, entity: EntityItem, column: ColumnItem): + """A method to generate a definition for a column in a database. Args: entity (EntityItem): The entity the column belongs to. - column (ColumnItem): The column to generate a description for.""" + column (ColumnItem): The column to generate a definition for.""" - column_description_system_prompt = """You are an expert in SQL Entity analysis. You must generate a brief description for this SQL Column. This description will be used to generate a SQL query with the correct values. Make sure to include a description of the data contained in this column. + column_definition_system_prompt = """You are an expert in SQL Entity analysis. You must generate a brief definition for this SQL Column. This definition will be used to generate a SQL query with the correct values. Make sure to include a definition of the data contained in this column. - The description should be a brief summary of the column as a whole. The description should be 3-5 sentences long. Apply NO formatting to the description. The description should be in plain text without line breaks or special characters. + The definition should be a brief summary of the column as a whole. The definition should be 3-5 sentences long. Apply NO formatting to the definition. The definition should be in plain text without line breaks or special characters. - You will use this description later to generate a SQL query. Make sure it will be useful for this purpose in determining the values that should be used in the query and any filtering that should be applied.""" + You will use this definition later to generate a SQL query. Make sure it will be useful for this purpose in determining the values that should be used in the query and any filtering that should be applied.""" if column.sample_values is not None and len(column.sample_values) > 0: - column_description_system_prompt += """Do not list all sample values in the description or provide a list of samples. The sample values will be listed separately. The description should be a brief summary of the column as a whole and any insights drawn from the sample values. + column_definition_system_prompt += """Do not list all sample values in the definition or provide a list of samples. The sample values will be listed separately. The definition should be a brief summary of the column as a whole and any insights drawn from the sample values. - If there is a pattern in the sample values of the column, such as a common format or that the values are common abbreviations, mention it in the description. The description might include: The column contains a list of currency codes in the ISO 4217 format. 'USD' for US Dollar, 'EUR' for Euro, 'GBP' for Pound Sterling. + If there is a pattern in the sample values of the column, such as a common format or that the values are common abbreviations, mention it in the definition. The definition might include: The column contains a list of currency codes in the ISO 4217 format. 'USD' for US Dollar, 'EUR' for Euro, 'GBP' for Pound Sterling. - If you think the sample values belong to a specific standard, you can mention it in the description. e.g. The column contains a list of country codes in the ISO 3166-1 alpha-2 format. 'US' for United States, 'GB' for United Kingdom, 'FR' for France. Including the specific standard format code can help the user understand the data better. + If you think the sample values belong to a specific standard, you can mention it in the definition. e.g. The column contains a list of country codes in the ISO 3166-1 alpha-2 format. 'US' for United States, 'GB' for United Kingdom, 'FR' for France. Including the specific standard format code can help the user understand the data better. - If you think the sample values are not representative of the column as a whole, you can provide a more general description of the column without mentioning the sample values.""" + If you think the sample values are not representative of the column as a whole, you can provide a more general definition of the column without mentioning the sample values.""" stringifed_sample_values = [str(value) for value in column.sample_values] - column_description_input = f"""Describe the {column.name} column in the {entity.entity} entity. The following sample values are provided from { + column_definition_input = f"""Describe the {column.name} column in the {entity.entity} entity. The following sample values are provided from { column.name}: {', '.join(stringifed_sample_values)}.""" else: - column_description_input = f"""Describe the { + column_definition_input = f"""Describe the { column.name} column in the {entity.entity} entity.""" if column.definition is not None: - existing_description_string = f"""Use this existing description to aid your understanding: { + existing_definition_string = f"""Use this existing definition to aid your understanding: { column.definition}""" - column_description_input += existing_description_string + column_definition_input += existing_definition_string - description = await self.send_request_to_llm( - column_description_system_prompt, column_description_input + logging.info(f"Generating definition for {column.name}") + definition = await self.send_request_to_llm( + column_definition_system_prompt, column_definition_input ) - logging.info(f"Description for {column.name}: {description}") + logging.info(f"Definition for {column.name}: {definition}") - column.definition = description + column.definition = definition async def extract_columns_with_definitions( self, entity: EntityItem @@ -286,33 +484,31 @@ async def extract_columns_with_definitions( ) distinct_value_tasks = [] - description_tasks = [] + definition_tasks = [] for column in columns: distinct_value_tasks.append( self.extract_column_distinct_values(entity, column) ) - if self.generate_descriptions: - description_tasks.append( - self.generate_column_description(entity, column) - ) + if self.generate_definitions: + definition_tasks.append(self.generate_column_definition(entity, column)) await asyncio.gather(*distinct_value_tasks) - if self.generate_descriptions: - await asyncio.gather(*description_tasks) + if self.generate_definitions: + await asyncio.gather(*definition_tasks) return columns async def send_request_to_llm(self, system_prompt: str, input: str): - """A method to use GPT to generate a description for an entity. + """A method to use GPT to generate a definition for an entity. Args: system_prompt (str): The system prompt to use. input (str): The input to use. Returns: - str: The generated description.""" + str: The generated definition.""" MAX_TOKENS = 2000 @@ -336,71 +532,76 @@ async def send_request_to_llm(self, system_prompt: str, input: str): token_provider = None api_key = os.environ["OpenAI__ApiKey"] - async with AsyncAzureOpenAI( - api_key=api_key, - api_version=api_version, - azure_ad_token_provider=token_provider, - azure_endpoint=os.environ.get("OpenAI__Endpoint"), - ) as client: - response = await client.chat.completions.create( - model=model, - messages=[ - { - "role": "system", - "content": system_prompt, - }, - { - "role": "user", - "content": [ - { - "type": "text", - "text": input, - }, - ], - }, - ], - max_tokens=MAX_TOKENS, - ) + try: + async with AsyncAzureOpenAI( + api_key=api_key, + api_version=api_version, + azure_ad_token_provider=token_provider, + azure_endpoint=os.environ.get("OpenAI__Endpoint"), + ) as client: + response = await client.chat.completions.create( + model=model, + messages=[ + { + "role": "system", + "content": system_prompt, + }, + { + "role": "user", + "content": [ + { + "type": "text", + "text": input, + }, + ], + }, + ], + max_tokens=MAX_TOKENS, + ) - return response.choices[0].message.content + return response.choices[0].message.content + except Exception as e: + logging.error(f"Unable to generate definition for {input}") + logging.error(f"Error generating definition: {e}") + return None - async def generate_entity_description(self, entity: EntityItem): - """A method to generate a description for an entity. + async def generate_entity_definition(self, entity: EntityItem): + """A method to generate a definition for an entity. Args: - entity (EntityItem): The entity to generate a description for.""" + entity (EntityItem): The entity to generate a definition for.""" name_system_prompt = """You are an expert in SQL Entity analysis. You must generate a human readable name for this SQL Entity. This name will be used to select the most appropriate SQL entity to answer a given question. E.g. 'Sales Data', 'Customer Information', 'Product Catalog'.""" name_input = f"""Provide a human readable name for the { entity.entity} entity.""" - description_system_prompt = """You are an expert in SQL Entity analysis. You must generate a brief description for this SQL Entity. This description will be used to select the most appropriate SQL entity to answer a given question. Make sure to include key details of what data is contained in this entity. + definition_system_prompt = """You are an expert in SQL Entity analysis. You must generate a brief definition for this SQL Entity. This definition will be used to select the most appropriate SQL entity to answer a given question. Make sure to include key details of what data is contained in this entity. Add information on what sort of questions can be answered using this entity. - DO NOT list the columns in the description. The columns will be listed separately. The description should be a brief summary of the entity as a whole. + DO NOT list the columns in the definition. The columns will be listed separately. The definition should be a brief summary of the entity as a whole. - The description should be 3-5 sentences long. Apply NO formatting to the description. The description should be in plain text without line breaks or special characters.""" + The definition should be 3-5 sentences long. Apply NO formatting to the definition. The definition should be in plain text without line breaks or special characters.""" - description_input = f"""Describe the {entity.entity} entity. The { + definition_input = f"""Describe the {entity.entity} entity. The { entity.entity} entity contains the following columns: {', '.join([column.name for column in entity.columns])}.""" - if entity.description is not None: - existing_description_string = f"""Use this existing description to aid your understanding: { - entity.description}""" + if entity.definition is not None: + existing_definition_string = f"""Use this existing definition to aid your understanding: { + entity.definition}""" - name_input += existing_description_string - description_input += existing_description_string + name_input += existing_definition_string + definition_input += existing_definition_string name = await self.send_request_to_llm(name_system_prompt, name_input) logging.info(f"Name for {entity.entity}: {name}") entity.entity_name = name - description = await self.send_request_to_llm( - description_system_prompt, description_input + definition = await self.send_request_to_llm( + definition_system_prompt, definition_input ) - logging.info(f"Description for {entity.entity}: {description}") - entity.description = description + logging.info(f"definition for {entity.entity}: {definition}") + entity.definition = definition async def build_entity_entry(self, entity: EntityItem) -> EntityItem: """A method to build an entity entry. @@ -415,14 +616,29 @@ async def build_entity_entry(self, entity: EntityItem) -> EntityItem: columns = await self.extract_columns_with_definitions(entity) entity.columns = columns - if self.generate_descriptions: - await self.generate_entity_description(entity) + if self.generate_definitions: + await self.generate_entity_definition(entity) + + # add in relationships + if entity.entity in self.entity_relationships: + entity.entity_relationships = list( + self.entity_relationships[entity.entity].values() + ) + + # add in the graph traversal + entity.complete_entity_relationships_graph = ( + self.get_entity_relationships_from_graph(entity.entity) + ) return entity async def create_data_dictionary(self): """A method to build a data dictionary from a database. Writes to file.""" - entities = await self.extract_entities_with_descriptions() + entities = await self.extract_entities_with_definitions() + + await self.extract_entity_relationships() + + await self.build_entity_relationship_graph() entity_tasks = [] for entity in entities: diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.Address.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.Address.json index ef5c083..aeafacd 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.Address.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.Address.json @@ -1,122 +1,155 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The AddressID column in the SalesLT.Address entity contains unique numeric identifiers for each address record in the database. The values are integers and are uniquely assigned to each address, ensuring that no two addresses share the same AddressID. This column acts as the primary key for the Address entity, facilitating indexing and efficient retrieval of address records.", - "Name": "AddressID", - "SampleValues": [ - 667, - 674, - 893, - 506, - 561 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The AddressLine1 column in the SalesLT.Address entity contains street addresses used to identify the location of various entities. The values in this column may include street names, numbers, and sometimes the name of a place or building such as a mall or marketplace. The format of the addresses can vary, including numeric street addresses and named locations. The data is primarily used for mailing and location identification purposes.", - "Name": "AddressLine1", - "SampleValues": [ - "2574 Milton Park", - "White Mountain Mall", - "Vista Marketplace", - "2505 Gateway Drive", - "6333 Cote Vertu" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The AddressLine2 column in the SalesLT.Address entity typically contains additional address information that complements the primary address line. The values may include PO boxes, apartment numbers, suite numbers, floor numbers, or other secondary address details. This column is used to provide further specificity to a mailing address beyond the main street address.", - "Name": "AddressLine2", - "SampleValues": [ - "Box 8033", - "PO Box 4023", - "Edward Way", - "Ste 1071", - "19th Floor" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The City column in the SalesLT.Address entity contains names of cities where the addresses are located. The values in this column are generally proper nouns representing various geographical locations. The city names are diverse and do not follow any apparent pattern or standard. These values will mostly be unique or may have limited repetition based on the addresses stored in the database.", - "Name": "City", - "SampleValues": [ - "Carrollton", - "Etobicoke", - "Burnaby", - "Waterloo", - "Great Falls" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The StateProvince column in the SalesLT.Address entity contains names of states and provinces for various addresses. The values can include both U.S. states and Canadian provinces, as indicated by sample values such as Missouri, Montana, British Columbia, Quebec, and Wyoming. This column is likely used to specify the regional subdivision within a country for each address.", - "Name": "StateProvince", - "SampleValues": [ - "Missouri", - "Montana", - "British Columbia", - "Quebec", - "Wyoming" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The CountryRegion column in the SalesLT.Address entity contains the names of countries or regions associated with addresses. The values are represented as full names of countries or regions, such as \"United States\", \"United Kingdom\", and \"Canada\". This column likely stores the standard names of countries or regions where addresses are registered.", - "Name": "CountryRegion", - "SampleValues": [ - "United States", - "United Kingdom", - "Canada" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The PostalCode column in the SalesLT.Address entity contains postal codes from various regions. The values include a mix of formats, such as alphanumeric patterns typical of UK postal codes (e.g., SW8 4BG, L4 4HB) and numeric patterns that can represent US ZIP codes (e.g., 98036, 97123, 84065). This column likely stores postal codes that identify specific locations, which may vary in format depending on the country.", - "Name": "PostalCode", - "SampleValues": [ - "SW8 4BG", - "98036", - "L4 4HB", - "97123", - "84065" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The column \"rowguid\" in the SalesLT.Address entity stores globally unique identifiers (GUIDs). These values are in the standard 32-character hexadecimal format divided into five groups separated by hyphens, following the common GUID notation. The unique nature of these identifiers helps ensure that each address entry can be distinctly recognized across different systems and databases.", - "Name": "rowguid", - "SampleValues": [ - "79972B72-7D84-4A33-AE27-44A5EFAEF39D", - "FBAC273F-934E-474F-9CCB-F96CA9AE889D", - "C1A9793E-50B5-431C-82DD-8B36ACC9AC4E", - "17A96F13-8658-4F02-A557-2BC4463ADE21", - "D9928CCC-FC35-435A-8A0F-6887813E0E06" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.Address entity contains timestamps indicating the last date and time a particular address record was updated. The values are in the format 'YYYY-MM-DD HH:MM:SS', which shows the date down to the second. This column is used to track changes and updates to address records over time, ensuring there is a history of modifications for auditing and data integrity purposes.", - "Name": "ModifiedDate", - "SampleValues": [ - "2006-12-01 00:00:00", - "2007-04-01 00:00:00", - "2006-09-01 00:00:00", - "2006-11-01 00:00:00", - "2007-09-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.Address entity contains detailed information about physical addresses, including primary and secondary address lines, city, state or province, country or region, and postal code. It also includes unique identifiers such as AddressID and rowguid, alongside a timestamp for the last modification of the record. This entity can be used to answer questions related to the location details of customers or facilities, verify address information, or analyze the geographic distribution of sales or services.", - "Entity": "SalesLT.Address", - "EntityName": "Customer Address Information" -} + "Entity": "SalesLT.Address", + "Definition": "The SalesLT.Address entity contains information about physical addresses used by the organization. This entity includes details such as the address lines, city, state or province, country or region, and postal code. It also tracks unique identifiers and the last modified date for records. This entity can be used to answer questions related to the geographical distribution of customers, shipping details, and the most recent updates to address information.", + "EntityName": "Address Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.CustomerAddress", + "ForeignKeys": [ + { + "Column": "AddressID", + "ForeignColumn": "AddressID" + } + ] + }, + { + "ForeignEntity": "SalesLT.SalesOrderHeader", + "ForeignKeys": [ + { + "Column": "AddressID", + "ForeignColumn": "BillToAddressID" + }, + { + "Column": "AddressID", + "ForeignColumn": "ShipToAddressID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress" + ], + "Columns": [ + { + "Name": "AddressID", + "DataType": "int", + "Definition": "The AddressID column in the SalesLT.Address entity contains unique numeric identifiers for each address record in the database. These values are sequential integers that uniquely distinguish one address from another within the entity. This column is likely used as a primary key, ensuring that each address can be uniquely and efficiently referenced.", + "AllowedValues": null, + "SampleValues": [ + 612, + 903, + 1013, + 864, + 756 + ] + }, + { + "Name": "AddressLine1", + "DataType": "nvarchar", + "Definition": "The AddressLine1 column in the SalesLT.Address entity contains the primary address information for a location. This column typically includes the street address, building number, and potentially additional location-specific information such as road names or special indicators. The values follow common address formats, including numerical street addresses and named locations, which may include abbreviations or directional indicators. The data is used to identify the first line in a two-part address structure, providing essential location details for correspondence or delivery purposes.", + "AllowedValues": null, + "SampleValues": [ + "2520 Flanders Road", + "250333 Southport Road, S.W.", + "9909 W. Ventura Boulevard", + "99-3 Forest Works", + "Kansas City Factory Outlet" + ] + }, + { + "Name": "AddressLine2", + "DataType": "nvarchar", + "Definition": "The AddressLine2 column in the SalesLT.Address entity contains secondary address information such as specific floor numbers, PO Box numbers, or additional details that supplement the primary address. The values typically provide more precise location details within a larger building or specify post office box numbers. The pattern in the sample values includes specific mentions of floors and post office boxes, often using common abbreviations like \"PO\" or \"P.O. Box\".", + "AllowedValues": null, + "SampleValues": [ + "19th Floor", + "Floor 7", + "PO Box 4023", + "P.O. Box 803", + "Box 8033" + ] + }, + { + "Name": "City", + "DataType": "nvarchar", + "Definition": "The City column in the SalesLT.Address entity contains the names of cities where the addresses are located. This column includes a variety of city names, which can be from any geographical location. The names are represented in a plain text format, without any specific pattern or standard format. The data in this column is used to identify the city component of an address within the SalesLT.Address entity.", + "AllowedValues": null, + "SampleValues": [ + "Kanata", + "Federal Way", + "Abingdon", + "Cambridge", + "Ferguson" + ] + }, + { + "Name": "StateProvince", + "DataType": "nvarchar", + "Definition": "The StateProvince column in the SalesLT.Address entity contains the names of states, provinces, or equivalent regions within various countries. These values are typically proper nouns representing administrative divisions such as Wyoming, Missouri, British Columbia, Montana, and Illinois. The data in this column is useful for identifying specific regions within a country for purposes such as shipping, billing, or demographic analysis.", + "AllowedValues": null, + "SampleValues": [ + "Wyoming", + "Missouri", + "British Columbia", + "Montana", + "Illinois" + ] + }, + { + "Name": "CountryRegion", + "DataType": "nvarchar", + "Definition": "The CountryRegion column in the SalesLT.Address entity contains the names of countries or regions associated with specific addresses. The values are in full-text format, representing the commonly used names of countries or regions. This column is used to identify the geographic location tied to each address in the database.", + "AllowedValues": null, + "SampleValues": [ + "United States", + "United Kingdom", + "Canada" + ] + }, + { + "Name": "PostalCode", + "DataType": "nvarchar", + "Definition": "The PostalCode column in the SalesLT.Address entity contains the postal codes for addresses. The values in this column consist of various formats, including both alphanumeric and numeric strings, which correspond to postal codes from different countries, such as the UK and the US. The column does not adhere to a single standard format and includes postal codes for various regions.", + "AllowedValues": null, + "SampleValues": [ + "W10 6BL", + "WA3 7BH", + "95501", + "49464", + "98045" + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.Address entity contains unique identifier values in the form of Globally Unique Identifiers (GUIDs). Each value is a 128-bit number represented as a string of hexadecimal characters, typically in the pattern of 8-4-4-4-12 (e.g., 00000000-0000-0000-0000-000000000000). This column is used to uniquely identify each record in the address table, ensuring that each entry can be distinctly referenced.", + "AllowedValues": null, + "SampleValues": [ + "CC91297C-567B-4186-96C8-2BA6F0875E73", + "0B49022D-8B49-4CF6-B0A3-46231CD48441", + "BD3035F6-4018-4E4C-8D70-6DD3F4FE8EB4", + "1A51283C-12BB-462E-A1B8-A0039C18E6D8", + "FF2BE5E9-7D22-4C1C-ACF8-199148E957AB" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.Address entity contains timestamps indicating the last date and time when the address record was modified. The format follows the SQL standard datetime format 'YYYY-MM-DD HH:MM:SS'. This column helps track the history of changes made to address records.", + "AllowedValues": null, + "SampleValues": [ + "2007-02-01 00:00:00", + "2008-02-01 00:00:00", + "2007-08-01 00:00:00", + "2007-09-01 00:00:00", + "2007-04-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.Customer.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.Customer.json index 9b03dce..e26a2cd 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.Customer.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.Customer.json @@ -1,197 +1,226 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The CustomerID column in the SalesLT.Customer entity contains unique numeric identifiers assigned to customers. The values in this column are integers and likely follow a sequential or semi-sequential pattern, which ensures that each customer can be uniquely identified within the database. The column does not contain any special formatting or non-numeric characters.", - "Name": "CustomerID", - "SampleValues": [ - 471, - 30118, - 668, - 29522, - 30104 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The NameStyle column in the SalesLT.Customer entity contains Boolean values indicating whether the customer's name should be in a specific format. In this case, the sample value 'False' suggests that the column can store either 'True' for names that follow a special format, or 'False' for names that do not. This Boolean flag allows for easy identification and separation of different name formatting styles within the customer data.", - "Name": "NameStyle", - "SampleValues": [ - false - ], - "Type": "bit" - }, - { - "AllowedValues": null, - "Definition": "The Title column in the SalesLT.Customer entity contains honorifics or titles used to address individuals. These values are typically abbreviations that precede a person's name and indicate their gender or marital status. Common titles include those such as 'Sr.' for Senior, 'Sra.' for Senora, 'Ms.' for Miss, and 'Mr.' for Mister.", - "Name": "Title", - "SampleValues": [ - "Sra.", - "Sr.", - "Ms.", - "Mr." - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The FirstName column in the SalesLT.Customer entity contains the first names of customers. The values are generally common first names in English, which might vary in length and formality. This column is expected to store unique entries for each customer's given name.", - "Name": "FirstName", - "SampleValues": [ - "Ted", - "Edna", - "Lucy", - "Esther", - "Chad" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The MiddleName column in the SalesLT.Customer entity contains the middle names or initials of customers. The values can range from full middle names to single letter initials, which may or may not be followed by a period. The column captures personal information that helps in identifying customers more precisely, especially when first and last names may be common.", - "Name": "MiddleName", - "SampleValues": [ - "B.", - "M.", - "I.", - "Francesca", - "Greg" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The LastName column in the SalesLT.Customer entity contains the last names of customers. These values represent a diverse set of family names, indicating it likely holds surnames from various cultural and ethnic backgrounds. The names appear to follow a standard format of single-word strings, typically capitalized. This column serves to identify and differentiate individual customers based on their last names.", - "Name": "LastName", - "SampleValues": [ - "Manzanares", - "Cheng", - "Farino", - "Caprio", - "Steele" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Suffix column in the SalesLT.Customer entity contains suffixes used in customer names. These values are typically abbreviated titles or rankings such as generational identifiers (e.g., Jr., Sr., IV) or academic/professional titles (e.g., PhD). The data in this column helps to distinguish between individuals with similar names by adding specific identifiers or qualifications.", - "Name": "Suffix", - "SampleValues": [ - "Sr.", - "PhD", - "Jr.", - "IV", - "II" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The CompanyName column in the SalesLT.Customer entity contains the names of companies that are customers. The values typically include the full names of businesses, often reflecting their services or products such as shipping, bike sales, and sports merchandise. The names are written in title case with spaces between words and usually include descriptive terms indicating the type of business.", - "Name": "CompanyName", - "SampleValues": [ - "Timely Shipping Service", - "Number One Bike Co.", - "Sports Merchandise", - "A Typical Bike Shop", - "Valley Bicycle Specialists" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The SalesPerson column in the SalesLT.Customer entity contains the usernames of sales representatives within the Adventure Works organization. The values follow a common format of 'adventure-works\\' followed by the representative's first name and a numerical digit. This pattern indicates a structured naming convention used by the company to uniquely identify each salesperson.", - "Name": "SalesPerson", - "SampleValues": [ - "adventure-works\\michael9", - "adventure-works\\jos\u00e91", - "adventure-works\\shu0", - "adventure-works\\jae0", - "adventure-works\\garrett1" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The EmailAddress column in the SalesLT.Customer entity contains the email addresses of customers registered with Adventure Works. Each email address appears to follow the format of a username followed by the domain \"adventure-works.com\". The usernames usually consist of the customer's first name or a combination of first name and a numeric value. This standard format ensures consistency in the storage and retrieval of customer email information.", - "Name": "EmailAddress", - "SampleValues": [ - "lindsey0@adventure-works.com", - "sairaj1@adventure-works.com", - "jean3@adventure-works.com", - "john16@adventure-works.com", - "suzanadeabreu0@adventure-works.com" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The column contains phone numbers in a standardized format, specifically in the North American Numbering Plan (NANP) format. Each phone number follows the pattern of three digits, a hyphen, another three digits, a hyphen, and then four digits (XXX-XXX-XXXX). This suggests the phone numbers are likely from the United States or Canada.", - "Name": "Phone", - "SampleValues": [ - "834-555-0132", - "695-555-0158", - "833-555-0167", - "351-555-0131", - "357-555-0161" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The PasswordHash column in the SalesLT.Customer entity contains hashed representations of customer passwords. The hash values typically consist of a long string of alphanumeric characters and symbols derived from cryptographic algorithms. These hashes are used for securely storing customer passwords and ensuring that the original passwords are not easily decipherable. The values do not follow a simple or predictable pattern, as they are designed to be unique and secure.", - "Name": "PasswordHash", - "SampleValues": [ - "hbXMO61Cy3vQxyCiHA7HyFryiQNgK7GAqMxsht+DVBI=", - "muiJ85PHJTw5ocOM+yS+gq+w8REzzCOfzXZNFyDZniI=", - "4wMARaGSdJ36NMWSghaEHOvqGA6TSKb3JZJ8QlNfnok=", - "FV6z03ywMJOumcU+TEoL/Z/s4YP2fe8B3MJUUTA0CHU=", - "gCWE10xc3haq9E82Ksvg2GS6WBBD0H0ZF25YAS0CfJ8=" - ], - "Type": "varchar" - }, - { - "AllowedValues": null, - "Definition": "The PasswordSalt column in the SalesLT.Customer entity contains salt values used for hashing customer passwords. These values are typically base64-encoded strings, which provide an added layer of security by ensuring that even if two users have the same password, their hashed versions will differ. The salt values help protect against rainbow table attacks and enhance password security.", - "Name": "PasswordSalt", - "SampleValues": [ - "wt1HllQ=", - "WWk6sxA=", - "ekE0M9I=", - "DKu7/UM=", - "sQMfTfM=" - ], - "Type": "varchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.Customer entity contains unique identifier values in the form of globally unique identifiers (GUIDs). These values are typically used to uniquely identify each customer record within the database. The GUID format follows a standardized 32-character string representation separated by hyphens, ensuring that each value is unique across space and time.", - "Name": "rowguid", - "SampleValues": [ - "ED1FF0E0-836D-42B3-A9DC-F8FAAF32ADBA", - "C6A84BC4-4131-4F49-9865-1F05530318CD", - "40984282-13F9-4B14-90B3-E7A17180195D", - "91154406-0118-4A11-BB1B-366EDFB5C97A", - "A029F31E-433B-4FA4-B442-B291D16A1B9F" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.Customer entity contains timestamps indicating the last date and time when a customer's information was modified. The values are in the datetime format, typically including both date and time down to fractions of a second. This column is used to track changes and updates made to customer records, facilitating auditing and data consistency.", - "Name": "ModifiedDate", - "SampleValues": [ - "2009-05-16 16:33:33.090000", - "2006-08-01 00:00:00", - "2007-05-01 00:00:00", - "2007-08-01 00:00:00", - "2005-08-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.Customer entity contains detailed information about individual customers and companies in the sales database. It includes personal attributes such as names and titles, contact information like email addresses and phone numbers, and security details like password hashes and salts. This entity is useful for answering questions related to customer identification, communication preferences, and sales representative assignments. Additionally, it can help track the latest modifications to customer records.", - "Entity": "SalesLT.Customer", - "EntityName": "Customer Information" -} + "Entity": "SalesLT.Customer", + "Definition": "The SalesLT.Customer entity contains information about individual customers, including both personal details and contact information. It includes unique identifiers, names, company affiliations, and communication details such as email and phone number. This entity can be used to answer questions related to customer identification, contact methods, sales representative assignments, and the recent activity or updates regarding customer information.", + "EntityName": "Customer Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.CustomerAddress", + "ForeignKeys": [ + { + "Column": "CustomerID", + "ForeignColumn": "CustomerID" + } + ] + }, + { + "ForeignEntity": "SalesLT.SalesOrderHeader", + "ForeignKeys": [ + { + "Column": "CustomerID", + "ForeignColumn": "CustomerID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress" + ], + "Columns": [ + { + "Name": "CustomerID", + "DataType": "int", + "Definition": "The CustomerID column in the SalesLT.Customer entity contains unique numeric identifiers assigned to each customer. These identifiers are integers that vary significantly in value, likely indicating they are auto-incremented or assigned sequentially. This column is used to uniquely distinguish each customer in the database, aiding in the management and retrieval of customer data.", + "AllowedValues": null, + "SampleValues": [ + 30022, + 340, + 208, + 397, + 29553 + ] + }, + { + "Name": "NameStyle", + "DataType": "bit", + "Definition": "The NameStyle column in the SalesLT.Customer entity contains boolean values indicating the style of the customer's name. 'False' typically suggests that the name is formatted in the default or standard style, while 'True' would suggest a non-standard formatting. The column is used to distinguish between different formatting conventions in the customer's name data.", + "AllowedValues": null, + "SampleValues": [ + false + ] + }, + { + "Name": "Title", + "DataType": "nvarchar", + "Definition": "The Title column in the SalesLT.Customer entity contains honorific titles used to address individuals respectfully. The values are typically common abbreviations for titles such as 'Mr.' for Mister, 'Ms.' for Miss, 'Sr.' for Se\u00f1or, and 'Sra.' for Se\u00f1ora. The column helps in identifying the form of address appropriate for male and female customers.", + "AllowedValues": null, + "SampleValues": [ + "Sra.", + "Sr.", + "Ms.", + "Mr." + ] + }, + { + "Name": "FirstName", + "DataType": "nvarchar", + "Definition": "The FirstName column in the SalesLT.Customer entity contains the given names of customers. These values can include a variety of international names and may include hyphens or other special characters. The names may be of any gender and vary in length. This column represents individual customer first names, which can come from diverse cultural and linguistic backgrounds.", + "AllowedValues": null, + "SampleValues": [ + "Yao-Qiang", + "Thomas", + "Jill", + "Jean", + "Jinghao" + ] + }, + { + "Name": "MiddleName", + "DataType": "nvarchar", + "Definition": "The MiddleName column in the SalesLT.Customer entity contains the middle initial of customers' names. The values are typically a single letter, sometimes followed by a period. This pattern suggests the column is used to store abbreviated middle names of customers. The data is useful for identifying individuals more precisely in records where middle names are provided.", + "AllowedValues": null, + "SampleValues": [ + "J.", + "M", + "C.", + "L.", + "K." + ] + }, + { + "Name": "LastName", + "DataType": "nvarchar", + "Definition": "The LastName column in the SalesLT.Customer entity contains the last names of customers. The values are typically capitalized and consist of alphabetic characters. This column is used to store the family or surname of each customer, which is a common format for identifying individuals in a customer database.", + "AllowedValues": null, + "SampleValues": [ + "Farino", + "Hamilton", + "Irwin", + "Coffman", + "Brewer" + ] + }, + { + "Name": "Suffix", + "DataType": "nvarchar", + "Definition": "The Suffix column in the SalesLT.Customer entity contains titles or honorifics that are appended to the end of customers' names. These suffixes often denote generational order (e.g., Jr., II, IV) or academic and professional qualifications (e.g., PhD, Sr.). The values are generally abbreviated forms of formal titles and follow common naming conventions.", + "AllowedValues": null, + "SampleValues": [ + "Sr.", + "PhD", + "Jr.", + "IV", + "II" + ] + }, + { + "Name": "CompanyName", + "DataType": "nvarchar", + "Definition": "The CompanyName column in the SalesLT.Customer entity contains the names of companies or businesses that are customers of the organization. The values typically represent the official or trade names of these companies, often including references to the industry or specific type of retail, such as bike stores or department stores. The names are generally descriptive and help identify the nature and focus of the businesses.", + "AllowedValues": null, + "SampleValues": [ + "Trendy Department Stores", + "Number One Bike Co.", + "Fifth Bike Store", + "Bike World", + "Great Bicycle Supply" + ] + }, + { + "Name": "SalesPerson", + "DataType": "nvarchar", + "Definition": "The SalesPerson column in the SalesLT.Customer entity contains identifiers for sales representatives. The values follow a specific pattern consisting of a domain prefix 'adventure-works\\' followed by the sales representative's name and a numeric suffix. This format is used to uniquely identify individual salespersons in the Adventure Works organization.", + "AllowedValues": null, + "SampleValues": [ + "adventure-works\\jillian0", + "adventure-works\\garrett1", + "adventure-works\\david8", + "adventure-works\\pamela0", + "adventure-works\\jae0" + ] + }, + { + "Name": "EmailAddress", + "DataType": "nvarchar", + "Definition": "The EmailAddress column in the SalesLT.Customer entity contains the email addresses of customers. The values follow a specific format, typically comprising the customer's first name or a variation of it, followed by a numerical digit and the domain \"adventure-works.com\". This structured format helps in identifying and organizing customer communication effectively.", + "AllowedValues": null, + "SampleValues": [ + "twanna0@adventure-works.com", + "joseph4@adventure-works.com", + "chris6@adventure-works.com", + "victor0@adventure-works.com", + "lindsey0@adventure-works.com" + ] + }, + { + "Name": "Phone", + "DataType": "nvarchar", + "Definition": "The Phone column in the SalesLT.Customer entity contains phone numbers associated with each customer. The phone numbers follow a specific format consisting of a three-digit area code, followed by a three-digit central office code, and a four-digit subscriber number (e.g., 103-555-0151). This format is likely consistent across all entries in the column. The values do not appear to conform to any international phone number format and seem to be fictional phone numbers without specific geographical significance.", + "AllowedValues": null, + "SampleValues": [ + "103-555-0151", + "718-555-0152", + "362-555-0162", + "290-555-0196", + "912-555-0149" + ] + }, + { + "Name": "PasswordHash", + "DataType": "varchar", + "Definition": "The PasswordHash column in the SalesLT.Customer entity contains hashed passwords for customers. The values are encoded in a string format, likely using Base64 encoding, which represents the hashed version of the customers' passwords. The hashes are used to securely store passwords in the database, ensuring that the original passwords are not stored directly. The length and characteristics of the sample values suggest that a consistent hashing algorithm and encoding method are used.", + "AllowedValues": null, + "SampleValues": [ + "miuh5Po0s3jNnKrMwmuROEApoKFRWumb1K1EMP0hGB0=", + "20rlqqjWOPLBi7oYKBrHMzouHcYl6OknJcV+yc0zQKo=", + "0ZfPkEBplSrQkVpmgzrlfblSeTpJ4CJwJu7aVWOuOSM=", + "cvqeC4fJcKwJ9jlluiWvK5/MyuSi8neLnjFDGdvzJy4=", + "haGTwCpR1pahJRX/490ASvk+bkWOZv828Z8Krd0XO50=" + ] + }, + { + "Name": "PasswordSalt", + "DataType": "varchar", + "Definition": "The PasswordSalt column in the SalesLT.Customer entity contains unique random strings used as additional input to hash functions to ensure password security. The values are typically base64-encoded strings, enhancing the security of stored passwords by making them less vulnerable to attacks such as rainbow table lookups. This increases the overall security of customer authentication by adding an extra layer of complexity to the password hashing process.", + "AllowedValues": null, + "SampleValues": [ + "oOIbGSo=", + "n/q5ims=", + "GR7idhc=", + "lkPNcdI=", + "aOFmjMY=" + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.Customer entity contains unique identifier values for each customer. These values are in the format of a GUID (Globally Unique Identifier), which is a 128-bit value typically represented as 32 hexadecimal digits separated by hyphens. The GUID values are used to ensure the uniqueness of each customer record across the entire database. This column is commonly used in replication and for merging data from different sources.", + "AllowedValues": null, + "SampleValues": [ + "0631F720-A96D-4505-A07C-11A954A67F6B", + "A2098F7B-3D3A-4894-90D7-C79C118845D5", + "36702D8C-0756-4B16-B0DA-8C97103D8B90", + "69AE5D43-31BE-4B76-BFBB-5A23C4788BBC", + "B143978A-3FC9-4077-A70A-DB4DFACEDC79" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.Customer entity contains the date and time when a customer record was last updated. The values follow the format of 'YYYY-MM-DD HH:MM:SS', indicating the precise timestamp of the modification. This information is crucial for tracking changes and understanding the recency of the data in the customer records.", + "AllowedValues": null, + "SampleValues": [ + "2005-11-01 00:00:00", + "2005-09-01 00:00:00", + "2005-08-01 00:00:00", + "2005-12-01 00:00:00", + "2007-09-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.CustomerAddress.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.CustomerAddress.json index 2cbd13a..978d464 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.CustomerAddress.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.CustomerAddress.json @@ -1,69 +1,99 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The CustomerID column in the SalesLT.CustomerAddress entity contains unique numerical identifiers assigned to customers. Each value is an integer and serves as a key to distinguish one customer from another. These IDs are crucial for linking customer information with their respective addresses and other related data within the database. The values are randomly assigned and do not follow a discernible sequential pattern.", - "Name": "CustomerID", - "SampleValues": [ - 30115, - 29969, - 29871, - 30051, - 30039 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The AddressID column in the SalesLT.CustomerAddress entity contains unique numeric identifiers for each address associated with a customer. The values are integers and are likely assigned sequentially or randomly generated to maintain uniqueness. This column serves as the primary key for addressing records in the table.", - "Name": "AddressID", - "SampleValues": [ - 478, - 893, - 865, - 644, - 589 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The AddressType column in the SalesLT.CustomerAddress entity contains types of addresses associated with customers. It includes designations such as 'Shipping' and 'Main Office', indicating the purpose or function of the address. This column helps categorize the addresses for various customer-related operations, such as shipping destinations or principal business locations.", - "Name": "AddressType", - "SampleValues": [ - "Shipping", - "Main Office" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.CustomerAddress entity contains uniqueidentifier values in the GUID format. These values are unique for each row and are typically used to provide a unique reference for each customer address. The format consists of a series of alphanumeric characters grouped into five sections separated by hyphens, ensuring each identifier is distinct across the database.", - "Name": "rowguid", - "SampleValues": [ - "882C6728-41E4-4BA5-9B26-F1341A0BFB11", - "D2500013-41B3-40CE-9135-8EA6C762D1BB", - "88D1889D-E045-40CC-A9CE-51C8614947E5", - "C6078B9A-2F95-4029-BE72-511345BE2A9A", - "33AA20BE-4DB5-42E4-83C6-64F377BE8E6C" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.CustomerAddress entity stores date and time information indicating when a record was last updated. The values follow the YYYY-MM-DD HH:MI:SS format. This column is useful for tracking the most recent changes made to customer addresses.", - "Name": "ModifiedDate", - "SampleValues": [ - "2006-11-01 00:00:00", - "2007-05-01 00:00:00", - "2006-01-01 00:00:00", - "2007-03-01 00:00:00", - "2007-02-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.CustomerAddress entity stores the relationship between customers and their addresses, specifying the type of address (e.g., billing or shipping) for each customer. It includes identifiers for both the customer and address, as well as metadata for tracking changes. This entity can be used to answer questions about where customers reside, the types of addresses associated with customers, and when address information was last updated.", - "Entity": "SalesLT.CustomerAddress", - "EntityName": "Customer Address Information" -} + "Entity": "SalesLT.CustomerAddress", + "Definition": "The SalesLT.CustomerAddress entity represents the relationship between customers and their addresses within the sales database. It contains key information about which addresses are associated with which customers, including the type of address (such as billing or shipping). This entity is useful for understanding and maintaining customer address records, ensuring accurate and up-to-date address information for each customer. It can be used to answer questions related to customer address assignments, address type categorization, and modification history of these records.", + "EntityName": "Customer Address Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.Address", + "ForeignKeys": [ + { + "Column": "AddressID", + "ForeignColumn": "AddressID" + } + ] + }, + { + "ForeignEntity": "SalesLT.Customer", + "ForeignKeys": [ + { + "Column": "CustomerID", + "ForeignColumn": "CustomerID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.CustomerAddress -> SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.CustomerAddress -> SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.CustomerAddress -> SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.Customer", + "SalesLT.CustomerAddress -> SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.CustomerAddress -> SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.CustomerAddress -> SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.Address" + ], + "Columns": [ + { + "Name": "CustomerID", + "DataType": "int", + "Definition": "The CustomerID column in the SalesLT.CustomerAddress entity contains unique identifiers for customers. Each value is an integer that uniquely identifies a customer within the database, ensuring that each customer can be distinctively referenced. These identifiers are likely autogenerated and do not follow a specific pattern other than being unique numeric values.", + "AllowedValues": null, + "SampleValues": [ + 29522, + 29937, + 29761, + 29843, + 29728 + ] + }, + { + "Name": "AddressID", + "DataType": "int", + "Definition": "The AddressID column in the SalesLT.CustomerAddress entity contains unique numeric identifiers for each address associated with customers. The values in this column are integers and serve as primary keys to uniquely distinguish different address records within the table. The identifiers do not follow a specific sequence but ensure that each address has a distinct identifier for reference purposes.", + "AllowedValues": null, + "SampleValues": [ + 643, + 867, + 810, + 993, + 601 + ] + }, + { + "Name": "AddressType", + "DataType": "nvarchar", + "Definition": "The AddressType column in the SalesLT.CustomerAddress entity contains descriptions of the type of address associated with a customer. The values can indicate different purposes for the address, such as \"Shipping\" for shipping addresses and \"Main Office\" for primary business locations. These descriptions help categorize the addresses based on their usage within the organization.", + "AllowedValues": null, + "SampleValues": [ + "Shipping", + "Main Office" + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The column rowguid in the SalesLT.CustomerAddress entity contains unique identifier values in the GUID (Globally Unique Identifier) format. These values are typically used to uniquely identify rows in the table, ensuring that each row can be distinctly referenced. The GUIDs follow a standardized 32-character hexadecimal format, divided into five groups separated by hyphens.", + "AllowedValues": null, + "SampleValues": [ + "0B887414-135A-43F6-94DC-60A220362C6D", + "5F9605D9-90C5-448B-9E38-13E53BD965F0", + "4CAA058D-61F5-4A49-9167-D1E57DCAC9CE", + "81390AF7-D4D0-4F4D-AF42-AB21F5713F14", + "F49E2C74-9BB9-462E-BCAA-67370F4D74A9" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.CustomerAddress entity contains the date and time when the record was last updated. The values are in the format of 'YYYY-MM-DD HH:MM:SS', indicating both the date and time of modification. This column is used to track and audit changes made to customer address records over time.", + "AllowedValues": null, + "SampleValues": [ + "2006-03-01 00:00:00", + "2005-09-01 00:00:00", + "2005-10-01 00:00:00", + "2006-01-01 00:00:00", + "2005-08-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.Product.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.Product.json index bf8f333..9b00e94 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.Product.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.Product.json @@ -1,215 +1,252 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ProductID column in the SalesLT.Product entity contains unique numeric identifiers for each product. These identifiers are represented as integer values. Each ProductID is distinct and used to uniquely reference products in the database.", - "Name": "ProductID", - "SampleValues": [ - 797, - 840, - 922, - 993, - 956 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The Name column in the SalesLT.Product entity contains product names that include both descriptive terms and technical specifications. These names often feature details such as model names, colors, sizes, and additional product features. The values generally exhibit a pattern of including specific features and identifiers that distinguish each product uniquely.", - "Name": "Name", - "SampleValues": [ - "Road-150 Red, 48", - "Road-650 Red, 52", - "Touring-3000 Yellow, 50", - "Taillights - Battery-Powered", - "ML Crankset" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The ProductNumber column in the SalesLT.Product entity contains unique alphanumeric codes assigned to each product. These product numbers typically follow a pattern that includes both letters and numbers, often separated by hyphens. The codes may have prefixes like 'BK', 'CS', or 'FR', which might indicate a category or product type, followed by a series of characters that likely represent specific attributes of the product.", - "Name": "ProductNumber", - "SampleValues": [ - "BK-R68R-48", - "BK-M82B-38", - "BK-M82S-44", - "CS-4759", - "FR-M21B-40" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Color column in the SalesLT.Product entity contains a list of color descriptions for the products. The values are generally common color names, occasionally combined to indicate multiple colors within a product (e.g., \"Silver/Black\"). These color descriptions are used for categorizing and identifying products based on their appearance.", - "Name": "Color", - "SampleValues": [ - "Grey", - "Silver", - "Silver/Black", - "White", - "Yellow" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The StandardCost column in the SalesLT.Product entity contains numerical values representing the standard cost of products. The values are typically precise decimal numbers, implying they might be calculated with a high degree of accuracy. This column is likely used for tracking the baseline cost associated with producing or purchasing each product within the database, and it plays a crucial role in financial and inventory management tasks.", - "Name": "StandardCost", - "SampleValues": [ - "199.3757", - "747.2002", - "55.3801", - "110.2829", - "8.0373" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The ListPrice column in the SalesLT.Product entity contains the selling price of each product. The values are represented as decimal numbers with four decimal places, indicative of precision in pricing. These prices range from moderately low to high, reflecting a variety of products with different price points in the inventory.", - "Name": "ListPrice", - "SampleValues": [ - "209.0250", - "337.2200", - "120.2700", - "769.4900", - "2443.3500" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The Size column in the SalesLT.Product entity contains values that represent the size of the product. The values include both numeric sizes such as '70', '44', and '50', and alphanumeric sizes such as 'M' for medium and 'S' for small. This indicates that the column accommodates a variety of size notations, likely depending on the product type.", - "Name": "Size", - "SampleValues": [ - "M", - "70", - "44", - "S", - "50" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Weight column in the SalesLT.Product entity contains numerical values representing the weight of products. The values are recorded with up to two decimal places and can range significantly. The weight is likely measured in a consistent unit, such as grams. This column is used for tracking the mass of different products in the inventory.", - "Name": "Weight", - "SampleValues": [ - "9130.77", - "6994.36", - "9430.14", - "8808.72", - "9715.90" - ], - "Type": "decimal" - }, - { - "AllowedValues": null, - "Definition": "The ProductCategoryID column in the SalesLT.Product entity contains numerical identifiers that correspond to specific product categories. Each unique ID represents a different category within the product catalog. The values are integers and are used to link products to their respective categories within the database.", - "Name": "ProductCategoryID", - "SampleValues": [ - 27, - 38, - 30, - 8, - 19 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The ProductModelID column in the SalesLT.Product entity contains numeric identifiers that uniquely represent different product models. These values are integers and serve as foreign keys that link products to their respective models. The column helps to categorize and manage products based on their model specifications.", - "Name": "ProductModelID", - "SampleValues": [ - 37, - 44, - 7, - 45, - 94 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The SellStartDate column in the SalesLT.Product entity contains datetime values representing the date and time when a product became available for sale. The format follows the standard SQL datetime format 'YYYY-MM-DD HH:MM:SS'. This column is used to track the sales start dates of products within the database.", - "Name": "SellStartDate", - "SampleValues": [ - "2007-07-01 00:00:00", - "2006-07-01 00:00:00", - "2005-07-01 00:00:00", - "2002-06-01 00:00:00" - ], - "Type": "datetime" - }, - { - "AllowedValues": null, - "Definition": "The SellEndDate column in the SalesLT.Product entity contains datetime values that indicate the end date for when a product is available for sale. The dates follow the format YYYY-MM-DD HH:MM:SS and represent specific points in time. This column is used to determine the cutoff date after which a product is no longer sold.", - "Name": "SellEndDate", - "SampleValues": [ - "2007-06-30 00:00:00", - "2006-06-30 00:00:00" - ], - "Type": "datetime" - }, - { - "AllowedValues": null, - "Definition": "The DiscontinuedDate column in the SalesLT.Product entity records the date a product was discontinued. This column contains date values indicating when a product is no longer available for sale. If the product is still active and available for purchase, this column may have a NULL value.", - "Name": "DiscontinuedDate", - "SampleValues": [], - "Type": "datetime" - }, - { - "AllowedValues": null, - "Definition": "The ThumbNailPhoto column in the SalesLT.Product entity contains binary data representing the thumbnail photo images of products in GIF format. The binary data adheres to the GIF file structure, starting with the \"GIF89a\" header, followed by image data encoded in binary. These values include image metadata, color tables, and pixel data, all encoded in a compressed format suitable for storage and rapid retrieval. This column is utilized for storing compact visual representations of the products for use in front-end applications, catalogs, or reports where a small preview image of each product is needed.", - "Name": "ThumbNailPhoto", - "SampleValues": [ - "b'GIF89aP\\x002\\x00\\xf7\\x00\\x00\\xd2\\xcd\\xc8yld\\xd5\\xd1\\xcc\\x82vn\\x9f\\x9f\\x9f\\xe9\\xe6\\xe3\\xc8\\xc2\\xbc\\xcd\\xc9\\xc4\\xda\\xd6\\xd2vib\\xa4\\xa4\\xa4\\xda\\xda\\xda\\xe3\\xe0\\xdd\\x94\\x8a\\x82\\x93\\x86~\\xb4\\xaa\\xa3\\xe1\\xde\\xdb~rk\\xca\\xc5\\xc0\\xdd\\xda\\xd5\\xeb\\xe9\\xe5\\xef\\xef\\xef\\xaf\\xaf\\xaf<0-\\xaa\\xaa\\xaaMA<\\xbb\\xb6\\xb1qd]\\xf0\\xee\\xecLLK\\xf1\\xf0\\xee\\xc4\\xbf\\xb9[ZY{{z\\xca\\xca\\xca\\xde\\xdc\\xd9\\xf3\\xf3\\xf3oaZ\\xee\\xec\\xea\\t\\x08\\x07\\xbc\\xb8\\xb5\\xb5\\xae\\xa8ECA\\x8b\\x8b\\x8abTM\\x94\\x91\\x8d\\x89}uUIC\\xd0\\xcb\\xc5\\x9d\\x99\\x94\\x99\\x8d\\x85lif]QJTSR\\x1d\\x1c\\x1b\\x86yq\\x8e\\x81y#\\x1d\\x1c\\x9d\\x92\\x8a\\xb9\\xb9\\xb9\\xaa\\xa6\\xa1\\xa5\\x9c\\x95\\xe4\\xe4\\xe4ea]\\xb4\\xb4\\xb4\\xae\\xa5\\x9d432865\\xf7\\xf6\\xf5\\xa1\\xa1\\xa1\\xb1\\xb1\\xb1\\x95\\x93\\x91-,,\\xf4\\xf2\\xf1i\\\\U\\xe6\\xe4\\xe1\\xf5\\xf4\\xf2,#!\\xfa\\xf9\\xf8\\xa1\\x97\\x8fdZT\\x9b\\x96\\x913-*a^[qnj\\xf7\\xf6\\xf48-*\\xdd\\xdd\\xdd\\xdb\\xd8\\xd5A51\\xa6\\xa1\\x9dmki\\x84\\x81~\\x81\\x7f{\\xf6\\xf5\\xf4\\xbe\\xbe\\xbe\\xec\\xeb\\xea\\x8a\\x87\\x84\\xbc\\xbc\\xbc\\xb9\\xb0\\xa9kfb\\xfa\\xfa\\xf9RPN\\xa1\\x98\\x92\\xbd\\xb5\\xae???\\xe4\\xe2\\xe1dc`\\xc1\\xbc\\xb7C>;yvsE84PMJ\\x1a\\x15\\x14\\x14\\x13\\x12\\xa9\\xa0\\x99J=9\\xba\\xb3\\xad\\xbc\\xbb\\xb9vtr\\xc0\\xb8\\xb1\\x87\\x85\\x83\\xa5\\xa3\\xa03)&999RFA\\x9d\\x94\\x8d\\xf8\\xf8\\xf7\\xd7\\xd4\\xd2) \\x1e\\xb3\\xb0\\xad&%%\\x9a\\x93\\x8d\\xdd\\xdb\\xd9\\xfc\\xfb\\xfbk_XPC>]YV\\xb0\\xa6\\x9f|og\\xeb\\xea\\xe8wql\\xa2\\x9e\\x9b\\x85|t\\x99\\x99\\x99JHF\\xf3\\xf2\\xf0\\xe7\\xe6\\xe5\\xe7\\xe5\\xe4\\xba\\xba\\xba\\xb6\\xb6\\xb6H:6rg`\\xd8\\xd3\\xce\\xc2\\xba\\xb3\\xac\\xa2\\x9a\\xa7\\x9e\\x96XKF<:9\\xa4\\x9a\\x92\\xf3\\xf1\\xf0+(&\\xc4\\xbd\\xb7\\x88\\x80y\\xa5\\x9b\\x941&$\\x81yr\\xbe\\xbc\\xb9\\xb8\\xaf\\xa7\\\\NH\\xef\\xed\\xec\\x8f\\x84|\\x83{u\\x7fyt\\xa7\\x9c\\x94XVT\\x1a\\x18\\x18\\x13\\x10\\x0f\\x0e\\r\\r\\xe6\\xe6\\xe6\\xe2\\xe2\\xe2\\xd4\\xd4\\xd4\\xc6\\xc6\\xc6\\xce\\xce\\xce\\xd1\\xd1\\xd1\\xc2\\xc2\\xc2\\xdf\\xdf\\xdf\\xd7\\xd7\\xd7\\xfd\\xfd\\xfd\\xe8\\xe8\\xe8\\xea\\xea\\xea\\xfc\\xfc\\xfc\\xed\\xed\\xed\\xec\\xec\\xec\\xfb\\xfb\\xfb\\xf7\\xf7\\xf7\\xf0\\xf0\\xf0\\xf1\\xf1\\xf1\\xf4\\xf4\\xf4\\xfa\\xfa\\xfa\\xf9\\xf9\\xf9\\xf5\\xf5\\xf5\\xfd\\xfd\\xfc\\xf6\\xf6\\xf6\\xf8\\xf8\\xf8\\xfc\\xfc\\xfb\\xfb\\xfb\\xfa\\xe7\\xe7\\xe7\\xeb\\xeb\\xeb\\xfe\\xfe\\xfd\\xe9\\xe9\\xe9\\xf8\\xf7\\xf6\\xf9\\xf8\\xf8\\xfb\\xfa\\xfa\\xf9\\xf9\\xf8\\xe7\\xe6\\xe6\\xe3\\xe2\\xe0\\xfd\\xfc\\xfc\\xeb\\xeb\\xea\\xed\\xec\\xec\\x98\\x91\\x8a\\xeb\\xea\\xeaHEC\\xcd\\xcc\\xca\\x9f\\x93\\x8b\\xcd\\xcb\\xc8\\xc4\\xc2\\xc0\\x8c\\x80w\\xd6\\xd3\\xd0\\xe9\\xe8\\xe8\\xea\\xe9\\xe9\\xac\\xac\\xab\\xdf\\xdb\\xd7=;;?3/\\x95\\x90\\x8a\\xb0\\xa9\\xa3\\xac\\xa3\\x9c\\xab\\xa5\\x9f;76\\xb6\\xb3\\xaf\\x8b\\x89\\x87\\xb7\\xb5\\xb2\\xf1\\xf0\\xf0\\xb7\\xaf\\xa8\\x9d\\x9c\\x9a\\xa3\\x9c\\x97\\xd7\\xd5\\xd3\\xd7\\xd6\\xd4\\xf5\\xf4\\xf4\\xf5\\xf5\\xf4\\xef\\xee\\xed\\xfe\\xfe\\xfe\\xbf\\xbf\\xbf\\x00\\x00\\x00\\xff\\xff\\xff!\\xf9\\x04\\x00\\x00\\x00\\x00\\x00,\\x00\\x00\\x00\\x00P\\x002\\x00\\x00\\x08\\xff\\x00\\xfb\\xfd\\x1bH\\xb0\\xa0\\xc1\\x83\\x06\\xf9)\\\\\\xc8\\x8f\\x97C^\\xbf\"\\n\\x13v\\xec\\x182f\\xc3\\x86-Kf\\x8cD1b\\x15\\x80\\x05\\xf3\\xd5k\\x96\\x0fZ\\xba\\xae,\\xd8U\\x0b\\xd7-\\x11\\xb6r}\\xd9\\x01\\xc4\\x02\\x06\\x05\\x04\\x04\"\\xdc\\xc9\\xf3\\x1f\\xc3\\x85\\x0f!J\\xa4h\\x11\\xa3F\\x8e\\x1eA\\x8a$i\\x12\\xa5J\\x96.a\\xca\\xa4i\\x13\\xa7\\xce\\x9eX\\t\\xfeT\\x184\\xe2\\xaf\\x89\\x15/f\\xdc\\xd8\\xf1c\\xc8\\x91%O\\xa6\\\\\\xd9\\xf2e\\xcc\\x995o\\xe6\\xccJ\\xd7\\xe7\\xd6\\xaeC\\xc3\\x1a%\\x9b\\xf4,S\\xb5O\\xdbJ\\x85[un]\\xac\\x0cy)S\\xd6\\xac\\xda\\xb12\\x15\\'\\x12\\x15{\\xb4\\xacR\\xb4M\\xd7Bu;5\\xae\\xd5\\xc3\\x88\\xbf\\x96\\xb16\\xcd\\x0b\\x13&\\x92@%!\\xc1\\xc4\\xcb\\xb4?\\xc8(\\xf35\\xbb4\\xadS\\xb6Q\\xdfR\\x95{\\x15tA~\\xd1\\xb29\\x99\\xc6\\x84\\x03\\x85%\\x0c\\xd0aA\\xc0\\x1c\\x1d\\x83\\x02&@\\xe5\\xcb8\\x16)m\\xcc\\x80qs&\\xcc\\xdb\\xb7\\xd6h\\xca\\x0c\\x11\\xffWu\\xa0\\x8b\\x8a!\\xb2dI\\x91\\x02\\xe7G\\x83\\x07h\\x0c\\x00@G\\x81\\x03\\x93e\\xf8\\xad_\\xfe{{\\xf3\\xe0\\xdd\\x9f\\xf9\\xd6\\xd0/eT\\xe1\\x81\\x1e]\\xa4\\xe3\\xcf\\x82\\x0c6\\xe8O,48\\xe0\\xca\\x18\\x07L@A\\x05\\xc6$\\xa3\\x9f_\\xb6i&\\x98n\\x9e\\x19V\\x17p\\xcd8\\xe1\\xc59y\\x80P\\x03\\x1f\\x830x\\x82\\x83\\x0b\\x820\\x08,J<\\xf2D\\x1d\\x000\\xb0\\x8d$\\xc6X\\xc6af\\x81\\xe5\\xd6Ya\\xbd!\\xa6L\\x19\\xd7\\x1c1\\x05\\x08H\\xc8\\x82\\x84\\x1c\\x0c\\x06r\\x81\\x15\\xa5\\xe4\\xf0\\xe2\\x82\\'x\\x93\\xc6\\t\\x19\\x94\\x80C\\x10\\x12\\x8c\\x00\\xc6<$\\xf4U\\x1b\\x90\\xda\\xfd\\x17b\\x91;5$\\x1e\\x17\\x91\\xd4\\x00\\x8b?\\'t D\\x1ct6\\xd1D \\x814QJ\\x95W\\xfa\\x93\\x06\\x1f\\'dA\\xc3\\x00\\x9f|0\\x01#\\xc4\\x98\\x89]\\x7f\\x1f\\x0e\\xd9\\x9d\\x91\\xd5\\xec0\\x04\\x93m\\xb4\\xe1\\x8f\\n\\x83\\xec\\xb1` 9\\x84\\x1aH)V\\xa83e,\\x0cv\\x00\\xcb\\t{\\xbc\\xb0\\xc8\\x13\\x8a2\\xffR\\xc1u\\xfcy($w\\x01\\xf2\\xc4\\x8f2N\\x84 D\\r*p\\xd3\\x88?H\\x08!\\x05\\xaaq\\x84\\x9aC\\x13V\\xbc\\x81H*4\\xbc@\\x07\\x9e\\xfe\\xc8\\x02\\xc2\\x82\\xa5\\xf4\\xb1H\\x0f\\x06\\x8c k\\x05?f\\xe7\\x1f\\x88D\\xf6\\xb4\\xab\\x13 \\xa4\\xd1A+\\x9c4\\x90\\x83?\\x1d\\xc4\\x91\\x05\\x9d|6\\xb1\\x87:\\x88(\\xb1\\x88\\x0b8\\xdc\\x90\\x00\\rW\\xa6\\xf1\\xae?\\xa5t2@;\\x07@\\xc0\\xc8>\\xfb\\x9c)n\\xa4\\xb8\\x8ax\\xd0\\xb9\\xe9\\xaeq\\xc6\\x13\\xe3@\\xe1\\x8f\\r\\xc66\\xe1O\\x1c\\xa5\\xeca\\xc5%4\\x04\\xd0@\\x10h\\xe0Q\\xc7&\\r\\xbc\\xb0 ,|0h\\x05\\x0b8\\xd0\\x03\\x006\\x8c\\x00\\xe30\\xa4\\xb7\\x02(\\xb1A\\xbc8\\x13B\\x1ak\\xb4\\x03\\xce#\\x01\\\\@l\\x1c\\x88\\xbc\\xdb\\xc4\\x05Yd\\xc0\\xc2\\x00O\\xe0!\\x00\\x04\\xc8e\\xf2A;\\xb2,\\xd8A\\xb5t\\xd2\\xb1\\x81\\x0ex\\x00\\xb2\\x846\\xc1\\xb39\\x10?\\xcd\\x88\\x80D\\x07g\\xe8\\xe0o\\ts\\xaa\\x00\\x0b\\x14P\\xaa\\xff\\xf3\\x86\\xd4\\x8b\\x80\\x83\\x07\\x02\\x8c$\\xe1\\x85\\x17\\x1e,!\\x80\\x82\\xf0\\xfa\\xb3\\xaa?\\x81\\xa42\\xc0\\x1c\\x06L0\\t4\\xd0\\xd4\\x1a$\\xdbk\\xee\\xc4k:\\x83\\xb8\\xf1\\x89\\x0b\\x01l\\x80\\x89\\r\\xfe\\x98\\x01K\\t\\xef^\\x90A\\'^>\\x00@\\x01DT\\xd3L3\\xd4xA\\xc1\\x16^\\xfb\\x93\\x03\\x9e\\\\n\\xd0\\xc0\\x18\\xe10\\xd0\\x8b/\\x9a\\xa7I\\xee\\xa4\\t5c\\x8b?\\x83\\x04\\xe1\\xc0\"\\x98$0\\xc0\\xbb\\x89\\xd8\\x90\\x80\\xa7V\\xf4\\xc1B\\x002\\xa0\\x81\\x05\\x07e4\\xe3\\xd0/N0q\\x87\\xe3\\x846\\x91C\\xd7{\\xb0p\\x03\\'\\x1f \\xb0\\x844\\xc9\\x8f+i\\xae\\x05\\xf1\\xd2\\xab?T\\x00\\x87\\xbf\\x12p\\x03\\x19\\x84\"u|\\xe8\\xc4\\x1b6\\xd6\\t\\x16\\x04N\\x13\\xe8\\xf0\\x803~q>aP\\xe3Z|\\xb0A\\x1c\\xf6\\xd0\\x849\\xe5\\xa0d2H\\x01\\x00 \\xf0\\x0cithsj*\\xd7A\\x94A\\x04O\\xf8\\xa3\\x07\\x0e\\x88@\\x00\\x06 \\x03v\\xd4\\xc0\\x1f\\x9e\\xa8\\xc1 X\\xf0\"\\xc0\\x91m|\\xb6\\xab 5\\xffP\\xb7*+P\\xc9S\\xb1H\\xc5\\x06\\xc6A9,P\\xc2\\x84h\\xd2_\\xc4\\xd8\\x047&\\xc8\\xe2\\x04\\xae\\x18\\xc7\"\"\\xb0\\x8aM\\x18\\xe0\\x08\\xfexG\\x07\\x06\\xf1\\x02\\x8f\\xc1\\x82\\x05\\tx\\x8f\\x00(P\\x852P\\x90@;`P\\x1c2`\\x85=\\\\\\xe0\\x04\\'`A\\t\\x06\\xe0\\x07<\\x90C\\r\\xbd8\\xa1\\xf2\\xf6\\xf7\\xb3\\x7fD\\xc3\\x19\\x1e\\xf0G(\\x04\\x18\\x81\\x1b\\x80\\x03\\r\\x99(\\x00\\xea\\xa4\\xf0\\xb1Nt-\\x07%p\\x01\\xfd\\xd0\\xa1\\n/\\x94a4^@\\x02\\x83\\x10q\\t#\\xbe\\x01UP(A\\x04d`3\\x06<\\xe3\\x19Q\\x84X\\xdb\\x0e\\xe2?\\x13(R\\x067\\x18@\\x17%\\xc0\\x80\\x03\\xf9C\\x0eP\\xca\\xc1\\x1b^\\x14\\x88\\r8@\\x11\\x95+\\x80*<\\xc0\\x81\\xf5-\\xa8\\r/\\xc8\\x82\\x15\\xb2\\x80\\x08<\\x96\\xa0\\x04\\x01p\\x00;\\x0e0\\x82k\\xc0\\xf2a=\\xeb\\x9cAxE\\x01Y\\xc8\\xa1\\x01\\x03\\xb8\\xc1{\\x00@\\x01/\\x80\\xe2\\x15\\x0fZP\\x1c\\xd4\\xf1\"Yd\\x00\\x07\\xed\\xd0\\x04\\x0c2\\x81\\xff\\x80\\x100(\\x034\\xb8\\xc4\\x05.@\\x07\\x16l,\\x01\\x1b\\x08\\xc0*\\xc04\\x82Y|\\x93g\\x9cSaA\\x941\\r\\n\\x0c\\xc1\\x1f.H\\xa7\\x0cP\\x91\\t\\x13L\\xa3\\n\\x050C\\x83N\\xf0;\\x7f\\xf0\\xa1X\\xa1@\\x82\\'\\xae$\\x0b\\x1a\\xb0\\x80\\x0e\\xa6zC*:\\xe1\\x0f)\\x94N\\xa1\\x0c\\xa5\\xc4C\\xd7\\x96B\\xe6\\x11D\\x19\\xd4\\xa0\\xc0\\xb5\\xa0\\xa0Q\\x8e\\x9a\\x80\\x1aN\\xf0\\x00:\\xe0\\xe9 <\\x0eB]\\x1d\\xf0\\xc6\\x9cB\\xc1\\x82\\x17\\\\\"\\xa6/\\xd8\\x80\\xa6\\\\\\x95\\xd0U(\"L\\x0e\\x8de8%\\xfaS\\'0\\xa2\\x05\\xfe\\xb0\\x82FeG\\x01\\'8\\x83\\x08\\x14 G\\x03\\x0e\\x08\\xa3\\x06\\xe5\\x80\\x0e\\x88\\xa0C\\x16\\x06\\x9a\\x85\\x17x\\tU\\x03\\xa0\\xde\"\\xb4\\xc9Mo\\x8a5\\xa2>\\x1dH4\\x9c`\\x02\\x01\\\\1\\x02\\x03p@\\x10\\x0eP\\x80*4\\xc3\\x10IX\\x02\\x00\\xe8a\\x8aw\\xcc\\xc9E\\xb1\\x08\\x84:\\xb2`\\xaa\\x81\\xaa\\xe3\\x12\\xb0\\xc3A\\x04\\xa0\\xb7\\x8a\\x00`b\\x95\"\\xd4\\xc5+\\x0f\\xdbS\\xfe\\xff)\\x16\\x91\\x08\\x88\\x84?20\\x00\\x1c\\xb8B\\x14\\xe8\\x00\\x85!J\\xe4\\x01\\x06\\xc0`\\x0c\\x02\\xdc@U3p\\t\\xd2\\x0e\\xd4\\xb4\\xce\\xfa\\x9edE9\\x05\\x17$\\xc0z\\xe0\\xd0\\x80\\x00\\xb0\\x11H\\xda.\\xcf\\xb6>iF\\x12 \\xc0\\x0e:)\\xa1\\x80c\\x10@\\x01\\xbc\\xe0\\x0c\\x13\\xa9\\xc2\\xb8hp\\xc5*\\x16Q\\x82\\xaa\\xe6\\xf5\\x12o\\xb8\\x04\\x1d\\xfa@\\x83\\x128\\xf2\\x01\\xeb\\x93\\x83\\x0c\"\\xb0\\x81\\x04\\x8c\\x83~X\\xf0\\x01\\x14\\xc1\\x89X\\xf0\\xfeC\\x19 =\\x00\\x1c\\xe8\\x84\\x84\\x00pB\\x14\\x13\\x00\\x03\\x04\\xc2a\\x8bB\\x14\\x00\\x1d\\x00\\xd0\\x84\"t\\xa0ZL\\x1c\\x82\\x05\\x9d\\xc8@\\x1f\\x94@@\\x19\\xf8\\x81\\n\\x03#\\x83u\\xb1I\\xd8n.\\x18\\xa2\\xb5-\\xe4?j\\x99\\tN\\xd0)\\x14Bx\\xc7\\x0f\\xba\\xa0\\x85\\x1f\\xe4\\xc0\\x06\\xaf\\x98\\xc1\\x14\\xa6\\x00\\x87!\\x98\\xc1\\x0cB\\x80&\\x12r\\x10\\x0bY\\xfc \\x01?0\\x03\\x12\\x86\\xb0*X\\xac\"\\x01\\x87\\xd8\\xa3\\x0e\\xd0\\xb0\\xddr\\xe4O\\x96\\xe2L\\x88!@A^X\\xd8 \\xff\\x1dB@\\x82\\n~@\\x08Q\\xfa\\xa3\\x06kxE$\\xb6`\\x068$\\xc2\\x13\\x9e\\x88\\x84\\n\\xba\\xe6\\x8fV\\x8cb\\n\\xde\\x10\\xc2\\x10\\xd2!\\x8bPD\\xe0\\x10P\\xd8\\x80\\x0b(W\\x88I O\\x90R\\x9c%BXX\\x00\\x00\\xcc@\\x05\\x9e@\\x02\\x12\\xda0\\x85u\\x0cZ\\x16[\\x98\\xc1\\x16B\\xb0\\x865P\\x81\\x0bp\\x98\\x81\\x1b\\xe0`\\x83+\\x1ea\\x1dd\\x88D\\x90\\xd3\\x90\\x86\\xea)A\\t&K\\x01\\x0c\\xb0\\x81\\xbf3\\x8f5\\xb1\\x04\\xe1E58\\x80\\x0eQ4@\\x05\\xa2&\\xf5:\\xec\\xdc\\x01\\x10\\xc0\\xa1\\x06\\xc0\\xeas$\\xe0\\xa0\\x82A/(\\n1\\x98A\\x07\\x86\\xc0\\x072pc\\x14\\xa5\\xc3\\x84\\x0bH!\\n\\x04\\\\.s\\x98F3Y\\x7f\\x93\\r/t\\xba\\x0e\\x9fh\\x84\\x19\\xbc\\xf1\\x03n\\x9cZ\\xd5[X\\x81\\x1b\\xf2p\\x84z\\xac\\xe1\\x08]\\x88\\x07\\xea\\xfc\\x11\\x83\\x18P!\\x11[ \\x84\\x16b\\x10\\x06V\\x0c\\xe0\\x11~\\xb0\\x19\\x04\\xa0\\x916c7X\\xc7\\x8a\\xadFqa\\xa0\\x01w\\xccA\\x0bZ\\xff\\xe0\\x01\\xae\\x131\\x856\\xd0\\xe0\\x15\\x97Z2\\x9e\\x97d\\x06A\\x93\\xa1\\x11\\x8b\\x18\\x057\\x1c\\xa1\\x07w\\xc4\\x80\\x10\\x84 E\\n$P\\x08J\\xe8Lm(\\xfc.\\xc8\\x07\\xc2\\x8bi\\x14W\\x00\\x12`\\xc3)N\\x81\\x82s\\xf4\\xa0\\x01\\x8fXD\\x02\\xa8@\\x85;\\x84\\xe0\\xeb_w\\xc3\\x1d\\xa80\\x83\\xeaq1\\n<\\x10\\x84<\\xe0\\x01\\x8f:\\xb0\\xe1\\x00XX\\x024\\x1a\\x86\\xf4AN\\xd1\\\\\\xcd0P\\x01 \\x80\\x85{\\xe0\"\\x1c_H\\xc1\\xd5G\\xc1\\nVt!\\x0faX\\xc1\\n\\xe2\\x11\\x8f\\x88\\xb1\\x9fx\\x1f\\xdb\\xc1\\xbfi\\x880\\x901\\x8cd\\x14c\\x1f\\x94\\x18\\x01\\xd4E\\x81\\x82\\xee\\x9f\\xe2\\x0b\\xfd\\x08\\xff\\xff\\x17\\xc4`\\x07\\x14h\\xe0\\xfc\\x1f8\\x009F\\xe0\\x03_\\x00\\xa3\\x02\\xc4(F\\x99h\\xe5\\xfc\\x8f\\x97>\\xfa\\n\\x11\\xcd0H\\xa0\\x8a\\x020`\\x04X\\x10\\x80\\x0b0\\x80\\x04\\xb8\\x12\\xf8p\\x0f\\x80\\x80\\x05#\\xf0\\x1c`\\xd0($\\xd0#e\\xe2(\\x1e\\x97c\\xf7\\x97\\x10@\\xf1\\x0b\\xce`\\r^\\x90\\x04\\x1c\\xa0\\n\\xaa\\xb0\\r:\\x13\\x82\"\\x819`\\x00\\x06&\\xb0\\x0f\\x1e\\xc0#\\xf8\\x91\\x1f\\x1b\"zIGH\\x1581@\\xa1\\x0c\\x18\\xe8\\x0c\\xceP\\x06\\xb1\\x91\\x83\\x17\\xc1\\x0c<\\x98\\x11\\x7f0\\x0c\\x7f\\x00\\x1b=X\\x19\\x12X\\x7f\\x14\\xe8\\x1do\\x93\\x18\\xe7\\xe3\\x15C!\\x19\\x92\\xa1\\x17\\xd5\\xe1#.hw\\x9a\\x86\\x84\\x16\\xf8\\x13x\\xf1\\x15\\x93\\xb1\\x17-Xw\\x99\\x96fV\\xa8\\x15w\\xf1\\x10^\\x01\\x16E\\x11\\x85E\\xe8]\\x84d\\x01\\xe1\\xd7\\x86n\\xf8\\x86p\\x18\\x87q\\xf8\\x05tX\\x87t(\\x06x\\x98\\x87bP\\t;\\xd0\\x87;`\\t\\x80\\x08\\x04\\x82h\\x04\\x16P\\x88\\xe7p\\x0e\\x18p\\x13\\n\\xa0\\x00E\\xa0{\\x90\\x08\\x00\\tGp\\x04-\\x10\\x10\\x00;'", - "b'GIF89aP\\x002\\x00\\xf7\\xff\\x00\\xd8\\xc4\\xba\\xc4\\xa6\\x98\\xcd\\x0e\\x08\\xbaeM\\xf8\\x88h\\xadZEeE;\\xfb\\'\\x16\\xfa\\xf9\\xf9\\x94\\x0f\\x07\\xf9\\x9a{\\xe5\\xd4\\xca\\xd6\\xd5\\xd5\\xc9\\xb3\\xa8\\xb4\\xb4\\xb4\\xd4\\xb6\\xa9\\xf9\\xf5\\xf3\\xec\\xe3\\xdc\\xa4\\xa4\\xa3\\xf8:$\\xe2\\xb9\\xa6\\x9f\\x9f\\x9f\\xb2\\xa2\\x9b\\xf5\\xf5\\xf5\\xcf&\\x17\\xa9\\x84w\\xb8\\x97\\x87{nj\\xed\\xed\\xed\\xfaU:\\x90J:\\xf3\\xed\\xe9\\xc5yd\\xe6\\xe6\\xe6\\xde\\xde\\xde\\xb2\\x88wl%\\x1b\\xca\\xb9\\xb1\\xf0\\xf0\\xf0\\xea|_\\xa4wf\\xf2\\xea\\xe5\\xab2#\\xe8\\xe8\\xe8\\xf9\\xa5\\x87\\xe5vZ\\xbe\\xbe\\xbe\\xc7YI\\x93i[\\xe7\\x87j\\x8ccU\\xdd\\xcb\\xc1\\xea]CvTJ\\xfe\\x01\\x01\\xfbB*\\xf9\\xb5\\x9b\\xfc\\xfa\\xf8\\x84#\\x18\\xd8\\xaa\\x96\\xfb\\x16\\x0c\\xaf\\xaf\\xaf\\xa4\\x9b\\x96\\xe3\\xce\\xc5\\xe7\\xd9\\xd0\\xe7\\x9c\\x82\\xa4F3\\xfc\\xfc\\xfb\\xa5!\\x16\\xc8\\x99\\x86\\xe6fI\\xc77$\\xb2\\x11\\x0b\\xf6\\xf1\\xeeN\"\\x1c\\x994(\\xe4\\xde\\xda\\x9awh\\xebC+5\\x03\\x05\\xfbkL\\x83WL\\xfbrT\\xea\\xe5\\xe2\\xb9\\xb9\\xb9\\xd7M4\\xc8\\x88w\\xdd\\xd1\\xca\\xfaK0\\xd5\\xbe\\xb2\\xe2\\x04\\x02\\xec(\\x18\\x9b\\x83z\\x87\\x86\\x86\\xaa\\xaa\\xaa\\xd8x]\\xb8\\xac\\xa6\\xf9\\xf7\\xf6\\xf93\\x1fE*#i\\t\\x06\\xdc\\x82f\\x876)\\x84lc\\xee\\xe8\\xe4x4*\\xfb\\x1e\\x12\\x9aVH\\xe8\\x8dr\\xb2I5\\xdb\\xd6\\xd3\\x8btjw\\\\S6/,\\xfe\\xfd\\xfc\\xe6\\x94z\\x99}q\\xd5\\x93z\\xb5ze\\xfd\\xfc\\xfbsKB\\xf9\\xc1\\xaa\\xe7S;8#\\x1e\\xc4r]\\xa7\\x95\\x8dl>3\\xca\\xca\\xca\\xe2\\xe2\\xe2\\xe9\\xdd\\xd5\\xda\\xda\\xda\\x85\\\\PH\\x05\\x03\\xb9\\xb7\\xb5\\xd1\\xd1\\xd1\\xe9\\xaa\\x92\\xfa}\\\\Y;3\\xfb`BZ\\' \\xf5\\xf2\\xf1T6-I\\x1a\\x14\\xb7U?\\xc3kR\\xce\\xce\\xce\\x83NC\\xdd\\x8ds\\xc7\\x81iW\\x06\\x03\\xa7\\x8b\\x80\\xc2\\xc2\\xc2\\xe9nT\\xf2sT\\xe3\\xc4\\xb4W\\x1c\\x15b4*\\xfb\\xad\\x91%\\x17\\x13\\x93\\x93\\x93\\x96\\x87\\x80\\xc9R3\\x0c\\x00\\x00\\xf4_A\\xc9\\xac\\x9e\\x98?1\\xeb\\xea\\xea\\xf2}^h\\x1a\\x16\\x9d\\x91\\x8c\\xe28#\\xf3\\x01\\x00\\xcd\\x94}\\x86>4\\xc6\\xc6\\xc6\\xce\\xcb\\xc9l\\x11\\x0c\\xf6\\xf3\\xf2\\x8a, D\\x11\\x0e\\xcbcJc+#x+\"tA6\\xd8eK\\xc6\\xbf\\xbb9\\x0e\\x0b\\xc5\\xc3\\xc2\\xac>-z\\x1b\\x11\\xdf\\x14\\x0bT\\x11\\x0c\\xdeH/\\xdcX>\\xbd\\xba\\xb9\\x98o`\\x91[Q\\xd5\\xd3\\xd2N/(\\xf2lM\\xe0\\xd9\\xd5\\xe4\\xe4\\xe4\\xfbgI\\xa3O?\\xf0\\xec\\xe9\\xfb,\\x1b\\xcd\\xc9\\xc6\\xe6 \\x12\\xf3\\n\\x05\\x99.!\\xad\\xa5\\xa0\\xe6\\xe1\\xde\\xc1\\xbd\\xba\\xca\\xc4\\xc0\\xa9\\x80o\\xa1bO\\x8a\\x7fz\\xa8\\xa7\\xa7\\xfb\\x81`\\xf3fG\\xfe\\xfe\\xfe\\xfe\\xfe\\xfd\\xd1\\xa4\\x91\\xfd\\xcf\\xbb\\xf5pQ\\xc1\\xa0\\x90\\xd0=\\'\\xb1\\xab\\xa7\\xad\\xac\\xac\\xd6\\xa0\\x9c\\xb3\\x8f~mVN\\xb6oZ\\xdfqU\\xef\\x8bz\\xba\\x9f\\x92\\xfa\\x90q\\xb0C10\\x11\\x0e.\\r\\n\\xe0\\xbc\\xb3\\xbf\\xbf\\xbf\\xff\\xff\\xff\\xff\\xff\\xff!\\xf9\\x04\\x01\\x00\\x00\\xff\\x00,\\x00\\x00\\x00\\x00P\\x002\\x00\\x00\\x08\\xff\\x00+\\xf4\\x1bH\\xb0\\xa0\\xc1\\x83\\x07](\\\\\\xc8p\\xa13\\x17T\\x9cQ\\x998\\xb1\\x90E\\x07\\x18\\x1d\\xf4\\xd8\\x08\\xcf\\x8b\\x97r\\x12$T\\x18Y\\xe1\\x93\\xc9O]Rv!\\xb7\\xa1\\x9f\\xbf\\x970c\\xca\\x9c)\\x13\\x9d\\xcd\\x9b\\xe8\\xe4\\xe8\\x943\\xa4gO\\x04@\\xc3\\x08\\xbd@\\x94\\x91\\x89\\xa3\\x1c8\\xc8Z\\x11\\xa2\\x1a \\x11\"\\x041``\\xe8\\xcf\\x1f]\\x97 j,7\\xd2%\\xcd\\xaf`\\xfd\\xe1\\xbc\\xb9\\x93\\xa7\\xcf!@\\x11\\x08\\rC\\xf4\\x82Q\\xa4J\\x99:\\x85*5\\x9a\\xa1HW\\xb3R\\xd1\\xe8E\\xa4\\xd7\\xb0\\x80a\\xe6,\\xabsH\\xe1\\xb3i\\xd7\\xb6}k\"\\xe9\\xd2\\xa6O\\xa3N\\xbd\\x9bWk\\x8f\\xbe\\x02\\x03\\xd3\\xb4\\x99\\x8e\\xf0\\x9d\\xcf\\xa0\\xef\\x9c\\xcd\\x81\\x16m\\xd0\\xa1E\\x8f6\\x8e\\x0b\\x99.\\x03\\xbbx\\xb1Z\\xc6\\xfcW\\xf3`\\x9d\\x9fs\\xe8V\\xbb\\xb6\\xf7\\xda\\xb4j\\x83\\xa3v\\xab\\xda\\xb1\\xdc\\xc8R\\xa9\\xc6\\xd6\\xcb\\xd7\\xaf\\xed\\x9d\\xb9\\xc3@\\x80\\xd0+I\\x92\\x0f\\x1fRh\\xd7\\x8e\\x1d\\xbb\\xf5^\\x10\\x14_\\xff`\\xbb\\xb88\\xeb\\xb9\\x92aW\\xde{\\xd9y\\xd8\\xc1\\x9f\\x11@\\xe0W\\x8a\\xcf\\x8b\\x17G\\xf2\\xbb\\xcb\\x7f\\xa4\\xd5}\\x10\\xa5\\xf0\\x13H\\x04\\x11\\xa0\\x91\\x026\\x1f\\xf4\\xd2K[\\xe5\\xc1\\xf5\\x18z\\xc9Q&\\x1b{\\xb4\\x81\\xd5\\x99\\x1cw\\x84\\xf1\\x83\\x15\\x8f``\\x8b\\x13\\x1d(\\xa2\\x885P@!\\xc5\\x89PX\\xa3H\\x07\\x1d8q\\x04\\x06\\x8fX\\x01\\xc0\\x02@\\x0c\\x88\\x066&0\\xa2\\xa3\\x8e\\xe6=\\x88\\xdck\\x122\\xd7^f3\\xc1\\x97B<\\xad(\\xb3\\x85\\x187`\\x11\\xa25\\'\"\"\\xa59R\\x9e\\xa8b\\x07X\\xdc0\\xc1\\x16\\x02\\xb4Q\\x04\\x00?,\\xc0D\\x818\\xe6\\xd8\\xe3q\\xae)\\xb7^sD\\xc64\\x18\\x02V\\x08\\xa0\\x8c\\x1a\\xd90\\xe9\\xa4\"&\"b\\x0e\\x01|\\xe2\\xc3\\'\\x95R@\\xb1b\\x96\\x13\\x1c\\xa0\\x86\\x00D\\x94\\x92\\x05\\x00W\\x00\\xf1\\xcd\\x8dH\\xad\\xe6\\xa3k\\xeaM\\xc8fmba\\xf8\\x83\\n\\xb7\\xb0\\xc2\\x83\\x1abLp\\xa7\\x89{\\xe2\\xa3\\xc0\\xa9\\xa7\\xe2\\xe3\\xa79\\x81\\x0e:A6j\\xf0\\xff`\\x83\\x00\\xc8\\xb4\\xf3@\\x16\\x8d>\\x9a\\xd4\\xae\\x93J\\xa6\\xa6\\xa5C\\xd6\\x96\\xd3\\x1d\\xf1\\x08`\\x83\\r\\xac\\xa8q\\xc0\\x04M\\xe2)E\\xa9\\n\\xb0\\xc0B\\'\\x9dH\\xab\\xc0\\xaaR\\xa8\\x98\\xa5\\x18\\x86\\xb2b\\xc3-D\\x88\\x13@\\x03321\\x85,J\\x9d\\xf7c\\xa5BV\\x08\\x93N\\xf1hq\\xac\\r\\x9ff#j\\x07\\xd6\\xb0\\x83\\x08\\x01\\xa6N\\x8b\\xc3\\xbf8T{-\\x01\\x88H\\xe1*\\xac\\xde\\x1e\\x8b\\x04\\n\\x1a\\xc0\\x82\\xab\\xb9\\xb2D\\xdck\\x84\\xcb\\xcd\\xe6^\\xa6?\\x18;/\\x0f\\x07\\xd8y\\xc3\\r\\xd6\\xccB@\\xb4\\x9d\\xe0\\x90\\xc7\\xc9y\\x04\\xcc\\xc2\\xb5\\xe6t *\\x16\\x13\\x88\\x11k\\xc26\\x84+O\\x00Y\\xcc`\\xee\\n\\x11\\xa3\\x99^\\x90\\x16\\xb7\\x89\\xe1\\x0b\\xb7\\xcc\\xebi\\xc7\\x13p\\x9c\\r\\x0f\\x1d\\x8c\\xcc\\x82\\xc98\\x9cx2\\x0e+\\x13`(\\xac\\xcb\\x8a\\xb1\\x05\\x0f\\xdc\\xcc\\xab\\x85\\x07M\\xdc\\\\\\xc2\\x15;\\xaf\\xe03\\xc5k\\x06\\xfb\\x12:w\\xa0\\xa1\\xf1\\xb1\\xc9.\\xcb\\xc3\\r\\xcfv\\xa0\\xc6\\tl\\x04q\\x08\\x0ej4\\xff)F\\xca\\x87(\\xd0\\xc1\\x01\\xd6\\x98\\x03E6[l\\xb1\\r\\xd7E\\x1fK\\x84\\x0ca\\xe3|\\xc57S\\x98\\xdd\\xda\\xcf\\x15S\\xe8\\x1e\\x86\\xfc\\xc8k4\\x9dI[\\x83\\xc3:\\x04\\x88AC\\x19s\\xacb\\x8f\\x18At2\\x81=\\x87\\x04\\xa1@6X(\\xb0\\x0e\\x0b\\x1dl\\xa3\\xb82\\xdc4>k\\r20\\x0c\\x0b\\x00\\xd4|\\xc3\\xd4\\xe5h\\x03\\xeb\\xae\\x1c\\x08t>/\\xb2\\xa0\\xf3\\xa0H\\'y\\x98\\x93M3_\\x94a\\x8a=[\\xf0\\x9b\\xcd\\x1cA\\xcc\\xc1\\x06\\x93\\n\\xe4\\xa1\\x00\\x16\\xdb`\\xb0\\r\\xef\\xb74.\\x80(Q\\xc0 \\xce=c3\\x11\\xc2\\xfd\\x10\\x02\\x99\\xf9\\xa5be\\xf8\\xc0\\xdb\\xd0[\\x16\\xa8\\xa0\\x84\\x85-\\x00\\x03\\x12_\\x98\\xc4*\\xf4@\\'L\\x98b\\x121(\\x03\\r\\xd4\\xd0\\x01\\x83\\xa9\\x01\\x03\\x18P\\x862\\xb4\\xa0\\x85\\xc6%\\xc0\\x00x\\x18\\xc43\\xe41\\xc6\\xe1\\x8fq\\xe8B4\\x18 \\x88B\\xd6\\x05h\\x9a\\xcbL:\\xee\\x90\\x84\\x08\\xac\\xe1\\x1a\\x9e\\xa3\\xd7\\x01\\xec5F2\\x86\"\\x14\\xc0Hc\\x19&1\\x879\\xb4\\xf1\\x8dF\\xa0\\x81\\x1e\\x98\\xe1\\x0e%2\\xd1\\x89H\\x88\\xc2\"\\x0c\\xe0\\x8aV\\xba\\xb2\\x95\\xf3(\\x048\\xc2\\xb1\\x0bCD\\x036\\xfbS\\xdb\"{\\x11\\x01zd \\x16\\x9e\\x9b\\xa1\\x13\\xc6X\\xc6P4\\x03\\x18\\xf5(\\x03\\x1b\\x96\\x19\\xc1\\x16\\xd4\\x03\\x8e4h\\x063lQGe4Q\\x0bH\\x90\\x84\\x1f\\xf4\\xb1\\x0f}8\\xc2\\x11\\x9b\\xe0\\x858+A\\x0baD\\xc1\\x12`(D1\\xc2\\xa1\\x8d]X\\xe5\\x18,\\xcc\\x0c:r\\x00\\x81\\x08\\xcc@\\x08\\x96X\\x03\\x12:\\xa5\\xff\\xb4\\tT\\xb2\\n\\xcdh\\x061\\xeaq\\x82\\x18\\xb0!\\x0618A\\x0b0\\x81\\x89P\\xaab\\x9a\\xd4\\xd4 \\x07\\x890\\x088,c\\x0f\\xdf\\xdc\\x04\\t\\x84a\\x06!\\x08\\xa1\\r\\xc8\\xe8\\x86\\x0ex\\x91\\x0cI\\xf4\\xc1\\x02\\xa4pF1\\x8eq\\x8c~\\x04\\xcd%.D\\xc3\\x0f\\xda\\x11\\x0b.(\\xa1\\x89\\x1f\\xe0\\xe2\\x11\\x86F\\x05\\x19~q\\x8a1\\x18\\xe0\\x0c\\xb5\\xa8\\xc0\\xc5^\\x82l\\x08| \\x02\\x92~@\\x89\\xe5!\\x8e&\\x80\\xd9\\x03d\\xa8\\xf6\\x13\\x08\\xc1\\x0bl\\x07\\x83\\x13~0F\\xaa\\tQ\\t^\\xa4a\\x1c#\\xb0C\\x01\\xba\\x91\\x80k\\x8c@\\x1d\\x0f\\xe0\\xc7\\x0ez\\x9d\\x0f\\x10P@\\x13u\\xff\\x80\\xb7g\\xe5\\xfd\\x0bO\\xec\\xa1\\x11p\\x00\\x85\\xbe\\x8d\\xfd\\x12\\x9d\\xe4 \\x0cI\\xd8\\xf2\\x02f\\xd0\\xecvh`\\x04\\x05\\xf7\\x80\\x0ePAV^\\x90\\xc1\\xe8\\tp\\x84\\x12\\x16\\x01q<\\xfc\\x82\\xe2\\x95\\xa8\\xc4\\xd1u`\\x063\\xf8\\xc2\\x0ck\\x80\\xee\\x08\\x8a\\xa0\\x0eu\\xe0\\x82\\x0f\\x1e\\x15B,\\xba1\\n\\x1aW\\x82\\x10\\x9e8\\x854\\xe61\\xec\\xae\\xd0\\xa43w\\xa0gv\\x02\\x01\\x04f\\x0b\\xbc\\x1d\\x04?\\xb1\\x0e\\x84\\xb1\\x08%\\x9c\\xe2\\x9b\\xa3P\\x02\\xc4%\\x11\\x85`\\xfc\"\\xeaR\\'\\xe9F\\xcd\\x90\\x0b\\x0f@C\\xc1\\x0c\\xc6\\x05%\\xe8Q\\x80X\\x98A\\x07\\xc90\\xba\\x8c\\xa3\\xder\\xb5\\xcf\\x03\\x14>p\\xfbfpC\\xcf\\xebD \\x10;\\xef\\xf9\\x08\\x9e\\x11\\x85\\\\p\"\\x18}_D0\\x82\\xe1\\x07I\\xc8\\xe0\\x190\\x18\\x06!f<\\x8ad\\xe8\\xe0\\xea\\x8d\\xcf:=\\xec ]\\x10\\x0c\\xe0\\x1a\\xb1\\xf0\\x05\\xe65_\\x89\\'\\xf4Q\\x1f/\\x8f\\xf9\\xcc1%\\x93\\x0b\\xc5\\x9d:\\x1f@\\x03\\xc0\\x99\\x1d\\x80\\x11\\xa0\\x00\\x1a\\x92\\x18\\x86\\xff\\x1f\\xc6\\xef\\x07<\\xc4O\\x1c#\\xc8\\x00\\x0c8Aq\\xa2\\xfb\\xfe\\xea\\xb1\\xf0\\xc05\\n\\x00]]C\\xa2\\x00\\xd7X\\x82\\xf2\\x93!\\xef\\xe6\\xf71\\xed\\xf6\\x86o\\xd3\\x07\\x18\\xe8`}9 \\x1f9\\x17\\x01\\x0b\\xd0l\\x1a\\xf0e2\\x00\\rQ\\x00\\r2\\x00\\x03(0\\x02\\x1a\\x10\\x00\\x01`\\t2\\xd0c\\x15\\x97\\x00:\\xd0\\r\\xdd\\x10\\x0bB0\\x7f\\x030\\x00\\x99\\xa5YB\\x80]:0\\n\\xcb@\\x08\\xfa\\x90vi\\xb7\\x07\\x89\\xc0v\\xc4\\xb6o\\xef\\x01\\x1d7\\xd7H@\\x00\\x00\\x0f\\x80w@\\'\\x0e\\xe2\\x90\\x01\\xf2p\\x81\\xb7\\x02\\x00\\r`\\t\\x83`\\x00J\\xb0\\x0c\\xb4@\\x02:\\xa0\\x03K\\x80\\x0cm\\xf0UT\\xe8d\\xdd\\xe0\\x0b\\xc2@\\x02\\x9b@o\\xa7\\xd0\\x85\\xf5\\xd6\\x085PeXF}\\x04\\x88!\\x19\\x92s\\xcb\\xc6\\x83\\xb0\\x80\\x81\\xb0\\x00\\x0b\\r\\xf0\\x00`\\x02\\x04\\xb3v\\x842`\\x00\\x8d\\x00N\\x8bP{\\x92 \\t\\xd0\\xd0\\x87}\\x18\\x05Q0\\x08~\\xb0\\x08\\xa7\\xb0\\x07^X\\x88\\xd2\\x10l\\x1a\\xe6\\rWf\\x83\\x9a\\xff\\x91)w\\x10b\\xff\\x86z?0\\x03\\x96\\xf8\\x03a\\x02\\x04\\x05\\x92\\x02h@\\r%\\xa0\\x01\\xcfP\\x03\\x89 \\rc\\x80Q\\xa2\\x96\\x08R$\\n\\xa3h\\x88{\\xd0\\x8a\\x85\\xd8\\x8ac\\xd0\\x08\\x18F\\x0e}P\\x0e\\xef\\xe0a4\\xf7\\x88\\x99\\x82Z\\x10p\\x1dh\\xa0}\\x04R h\\xe0\\x1d\\n\\x92\\x02L\\x00\\x00\\xf7`Wx\\x90\\x08\\x8d0\\x06\\xceX\\x8a\\xad\\x18\\x8d\\xd2\\xb8\\x07\\xd9f\\x00a\\x08z\\xef\\xa0\\x11\\xa6\\xa5\\x8bnbs7\\xd7\\x8b\\xd6\\x11\\x8e\\xe0\\xe1\\x1bI0\\x05W\\xd0\\x00\\x1a`W\\x9a\\x96\\x08\\xa38j\\xa4\\xe8\\x8c\\xeeXjR\\x94a\\xdf\\x15^\\xceP\\x08m\\xc5\\x8d5a\\x86\\xbaq\\x80\\x07\\x08\\x1c\\x08@\\x1aj\\x91\\x04\\xb2\\xc0\\x04\\x93v\\x0f\\x96pi\\x83P\\x03x\\xb0i\\x06\\xf0\\x90\\x9bV\\x035\\x90\\no@\\x07\\x96`\\x01\\xe9\\x04\\x0e\\xe0\\xf0R\\xfa\\x08\\x16l#\\x1a\\x9fq\\x18g\\x81\\x16lA\\x90\\xdfp\\x05Fh\\x01\\x1a`\\t\\x19@\\x07t\\xd0\\x040\\xe9\\x92\\x96`\\t\\'\\x95N+\\xc5R\\xf1\\x86D\\x86\\x1d)\\x16cq\\x1bf\\xe1\\x13A\\xe1\\x16\\xd80\\x05L\\xb0\\x00\\xbb\\x00\\x00%P\\x02\\r\\xd0\\x00\\xa4\\xc0\\x94\\rP\\x02\\xeb\\xd4N\\xbb\\xe0N[\\xe4\\x88;\\xc9\\x93cQ\\x16#\\x99\\x18la\\x14\\xd8\\x80\\x06S\\xf0\\rL \\x08\\xd4\\xe0\\x06fy\\x96f\\xa9?UY\\x01=\\x80\\x10n\\xf9\\x96p\\xd9\\x10\\x0c\\xf1\\x10tI\\x11T\\x80\\x8f\\xf8\\xd8\\x03\\xda\\xb8\\x11=\\xd0a\\x1e\\xd1\\x88\"A\\x12\\'\\xf1\\t\\xffP\\x98\\x86y\\x98\\x88\\x99\\x98\\x8a\\xb9\\x98\\x8c\\xd9\\x98\\x8e\\xf9\\x98\\x85\\x19\\x10\\x00;'", - "b'GIF89aP\\x002\\x00\\xf7\\x00\\x00\\xc6\\xc6\\xc6tsr988\\xec\\xec\\xec\\xf4\\xf4\\xf4\\xc3\\xbb\\xb8\\x8ahf|zy\\xf0\\xf0\\xf0\\\\[Z\\xf9\\xf9\\xf9lXV\\xbd\\xb6\\xb2TSS\\xce\\xce\\xce\\x96\\x96\\x95\\xc3\\xbf\\xbc\\xb2\\xb0\\xad[JH\\xa0\\x9d\\x9c\\xb1\\xb0\\xb0\\xf2\\xf2\\xf2\\'\\'\\'\\x7f}{\\x9a\\x9a\\x98\\x9b\\x96\\x93\\xfc\\xfc\\xfcKJJ\\xee\\xee\\xee\\xa5\\x8a\\x86\\xe2\\xe2\\xe2\\x94\\x8d\\x8b\\xb1\\xac\\xa9\\x88\\x87\\x85\\x92\\x91\\x91\\x95kj\\xe6\\xe6\\xe6D95\\xd4\\xd4\\xd4\\xe8\\xe8\\xe8\\xa2\\xa2\\xa1\\x8f\\x8e\\x8dl_Z\\xad\\xa4\\xa1\\xdf\\xdf\\xdf\\xa4\\xa4\\xa4\\xaf\\xaf\\xafxut\\xe4\\xe4\\xe4\\xda\\xda\\xda\\xe3\\xe1\\xde\\xa1\\xa0\\x9e\\xcb\\xc8\\xc5\\xd2\\xce\\xcbuTS\\xea\\xea\\xea\\xa9\\xa8\\xa6\\xb4\\xb4\\xb4\\x1d\\x1c\\x1c\\xc2\\xc2\\xc2\\xca\\xca\\xca\\xd0\\xd0\\xd0efe\\x90\\x90\\x8fqlkuqn\\xdc\\xdc\\xdcaa`\\xb8\\xb8\\xb7\\xb9\\xb8\\xb5\\xaa\\xaa\\xaa\\x83\\x7f}\\xd7\\xd6\\xd6\\x9f\\x9f\\x9f\\x98\\x97\\x97Y\\x18\\x18\\x8a\\x89\\x89/\\x1c\\x1b\\xa2zwjjh\\x9a\\x82\\x7f\\xbe\\xbe\\xbeEEE\\xbc\\xbc\\xbb\\x8d\\x8c\\x8a\\xba\\xba\\xba[\\x06\\x07\\x9b~{\\xe0\\xe0\\xe0\\x8c|z\\x9e\\x86\\x82idc\\xe2\\xdd\\xd9gDD\\x93rp1&$\\xad\\xac\\xabzxw\\xa5\\xa4\\xa1ZAA\\xd8\\xd6\\xd4\\xd3\\xd2\\xd2\\x9e\\x91\\x8be\\x07\\x08v_]\\xc8\\xc7\\xc7\\xbc\\xbc\\xba\\x86\\x85\\x85\\x9c\\x9b\\x9a\\x9d\\x9c\\x9b\\x83sr\\xcc\\xcb\\xcazcb}mk\\xcc\\xcc\\xcb\\x03\\x02\\x02\\xdd\\xdc\\xdaonl\\xc5\\xc5\\xc3\\xd5\\xd4\\xd2\\xd1\\xd0\\xce\\x91\\x85\\x82\\x85\\x84\\x83\\x95\\x94\\x93\\xd6\\xd0\\xd0\\x8c\\x8a\\x89hhfmlj\\x8b\\x87\\x86\\xb8\\xa2\\x9d\\x9d\\x8c\\x88\\x8eom\\xa4\\xa3\\xa1\\x9anm\\xc0\\xc0\\xc0\\xab\\xaa\\xa8\\x83\\x82\\x82\\xa2\\x82\\x7fY\"\"\\xa8\\xa8\\xa7\\xb6\\xb6\\xb6JCB\\xd9\\xd8\\xd8\\x9dtr\\x86\\x82\\x81\\x94\\x93\\x91\\xc5\\xc3\\xc1\\x9c\\x9c\\x9c\\x9a\\x88\\x85\\xdb\\xda\\xd8@))\\xa0\\x95\\x93oii\\xe4\\xe4\\xe2\\xbb\\xbb\\xb9\\xa7\\xa6\\xa5\\xa6\\xa6\\xa6\\xcc\\xc5\\xc2cba\\xaa\\x90\\x8c\\xac\\xad\\xacpc`\\xda\\xd9\\xd8I\\x16\\x16\\xdf\\xde\\xdd\\xb5\\xb4\\xb2\\xae\\xae\\xac\\xb8\\xb6\\xb3\\x9f\\x9e\\x9d\\xcc\\xca\\xc7\\xea\\xea\\xe9\\xbc\\xba\\xb7\\xd5\\xd5\\xd5\\xd3\\xd2\\xcf\\xed\\xed\\xededbWUU\\xba\\xae\\xac\\xc3\\xc2\\xbf\\x9e\\x9d\\x9c\\xa1\\x9b\\x98\\x97|yD\\x0c\\r\\xb3\\xb3\\xb2\\xac\\xab\\xaa\\xed\\xec\\xec\\xa6\\xa5\\xa4\\xdd\\xdd\\xdd\\xc9\\xc9\\xc9\\xb9\\xb9\\xb9\\xa8\\xa2\\x9e\\x11\\x0e\\x0e\\xfb\\xfb\\xfb\\xf7\\xf7\\xf7\\xfa\\xfa\\xfa\\xf6\\xf6\\xf6\\xaa\\xa9\\xa8\\xe1\\xe1\\xe1\\xf7\\xf7\\xf6xke\\xab\\xa0\\x97poo\\xe9\\xe9\\xe9ddd\\xf8\\xf8\\xf8\\xaf\\xad\\xac.--\\xf3\\xf3\\xf3\\xb0\\x8f\\x8c\\xed\\xee\\xee\\xf4\\xf3\\xf4Y\\x0f\\x0f\\xf6\\xf7\\xf7\\xb6\\xa2\\xa1\\xb8\\xa7\\xa6\\xf5\\xf6\\xf6\\xc7\\xb4\\xb0\\xf1\\xf1\\xf1\\xf5\\xf5\\xf5\\xd1\\xd1\\xd1\\xfc\\xfc\\xfb\\xc1\\xc1\\xc0\\xef\\xef\\xefPOO\\x8c\\x8b\\x8cmIIZ22\\xd7\\xd7\\xd7?>>\\xe7\\xe7\\xe7\\xdb\\xdb\\xdb\\x89`_YXX]QO\\xf4\\xf4\\xf3\\x89yw\\xeb\\xeb\\xeb\\xb4\\xb3\\xb3\\xf0\\xf0\\xee\\xd9\\xd9\\xd9\\xaa\\xa9\\xaa\\xa9\\xa9\\xa9\\xa8\\x99\\x95__^\\xbd\\xbd\\xbd\\xd8\\xd7\\xd6\\xfb\\xfb\\xfa\\xef\\xf1\\xf1\\xf6\\xf6\\xf5\\xb5\\xb5\\xb4\\x9a{w\\x95wu\\xbf\\xbf\\xbf\\xfd\\xfd\\xfd\\xfe\\xfe\\xfe\\xff\\xff\\xff!\\xf9\\x04\\x00\\x00\\x00\\x00\\x00,\\x00\\x00\\x00\\x00P\\x002\\x00\\x00\\x08\\xff\\x00\\xf9\\xfd\\x1bH\\xb0\\xa0\\xc1\\x83\\x06\\xfd)\\\\\\xe8\\xaf\\x9f\\xc3~\\x1a\"\\x02\\x03&L\\x98\\x02f\\xc1\\x82\\r\\xd3F\\xe0Y6\\x04\\xde\\\\\\r\\xb8q\\x82\\x04\\x0c\\x0f,v\\xc5\\x18gb\\x9b\\x03\\x1e\\x00vD\\xe9\\x95\\xc3\\x85\\x91\\x16I\\x04\"\\xdc\\xc9\\xf3\\x1f\\xc3\\x85\\x0f!J\\xa4h\\x11\\xa3F\\x8e\\x1eA\\x8a$i\\x12\\xa5J\\x96.a\\xca\\xa4i\\x13\\xa7\\xce\\x9eX\\t\\xfeT\\x184\\xa2\\x86\\x89\\x15/f\\xdc\\xd8\\xf1c\\xc8\\x91%O\\xa6\\\\\\xd9\\xf2e\\xcc\\x995o\\xe6\\xccJ\\xd7\\xe7\\xd6\\xaeC\\xc3\\x1a%\\x9b\\xf4,S\\xb5O\\xdbJ\\x85[un]\\xac[\\x1b>\\xf4\\n\\xb6\\xe8X\\xa4f\\x97\\xa6u\\xca6\\xea[\\xaar\\xaf\\x1e\\xde\\x99\\x18\\xefW\\xa2b\\x8f\\x96U\\x8a\\xb6\\xe9Z\\xa8n\\xa7\\xc6\\xb5\\xba\\xb9g\\xe7\\xc5y\\x1d\\x8b\\xee+\\xd9t`\\xcb\\xaa\\x0bkn\\x9d\\xf0\\xae\\xd0\\x89\\xa0\\x15\\x84\\xe6\\x1b\\xb94\\xe0\\xca\\xa9\\tg\\xe6\\xe9\\xef\\x19p\\x87\\n9\\xdf\\xfdj1\\x981|\\xc6\\x86e\\xdcN\\x9c\\xf4_\\xca\\xa8\\x07c\\xfff\\x8d0M\\x14\"\\xd1\\xaei\\x0b\\x06\\x0cz\\xf4\\x82?\\x1dj\\xbbC\\x0b\\xd2\\x8b=\\xf5\\x94\\xb9\\xf2V\\xe1\\x99\\xb6a\\x1bA\\xe6\\xddd\\xa7\\tv\\xd9j\\x86%\\xc4\\x02\\x05\\xa6\\xa4qG\\x0f\\x08h\\xa3\\x800\\x1a\\xf4\\xb3\\x90V\\\\AD\\n\\x19\\x0c\\x1cSB\\x13\\xbf\\xe8\\x90L/t\\xc0\\xa0\\n\\x7f\\x04p4\\x9a_\\x04\\xde\\x96\\xdcx\\tjU\\x857,TB\\x87,\\x9b\\xdcB\\xc4\\t\\x15h\\xc3\\x8c=\\x162\\x04\\x110\\xae4c\\x06\\x17\\x1d~\\xf8\\xcb\\x1cs\\x90\\xb3H\\x1a\\x95x\\xc0N6\\xcf\\x10\\xb0bm\\xc7\\x85w\\xa0n\\x07\\xf5#\\x84\\x11\\xe5`Q\\x86&-D\\xf2\\xc2\\x1a\\xef\\x94\\xe3\\xca3\\xccpc!D\\x048\\x80B\\x00\\xc7\\x1c\\xd9a#_4\\x92\\xcc\\x92\\x88\\xb4\\x90F\\x19,(\\x83\\xc03\\x84\\x16\\xc7\\x94\\x07\\xc5\\x90\"\\x04r\\xe2!\\xb8\\x9b?\\x1aPc\\x87(\\xfc\\xec\\x80\\x0b\\n\"\\x04\\xe0\\x03 rT\\x92\\x89+\\xea\\x04S\\x01\\x1f\\xd6\\xb8\\xf1\\x8d\\x00%,`\\xe7\\x11G\\x88A\\x0c1k\\xcc\\xff\\xf1\\xcd,\\xb8t\\xb3\\r\\x16\\xaa\\x0cZ\\x81\\xa1$\\xa0$\\xc4;\\xe3 aB\\x19\\xb8)G\\x9eV\\x1a(0\\x80(3\\x98B\\xcc\\x0c?\\xbc\\xb0\\x80\\r\\x06P\\x02\\x02\\x03\\xb1T\\x93E::\\xcc\\xf1K\\x13%\\x84BK\\x04\\x18\\xfc\\x91\\xcc\\x0f\\x84\\x88\\xb1I\\x08\\xe4\\xb0\\xd1F;\\x92\\xb0\\x02\\x83+\\x15\\xec\\xaa\\xd4\\r&\\xf8\\xa2B#\\xe8\\xcc\\x12\\x05\\x0fo\\x04\\xfc\\x06/[.\\x07\\x1f0\\np@\\n\\x18\\x9a\\x80\\x81B\\x18\\x12\\x84\\x83\\xc69^$\\x02M\\x1c\\x160\\xc9d\\tu\\xb0\\xd1\\x0c\\x18l$AE\\x00T\\xa4\\x80\\xc8\\x0c\\x87`0\\x8b\\x12\\x87\\x10\\xf1\\x06\\x1d\\xcad\\xb3kH\\x8eD \\x83\\x19\\x12|\\xb1d\\xbb\\xf9\\xf0#\\t\\x00\\x00\\xd8\\x91\\x9b\\xc1\\xc8*pO1\\x9aP\\x90D\\x02\\x11\\xdb\\x80\\xc6 W|r\\x8c\\xc6\\xbf`\\x82\\xc2-.\\x80q\\x081mP\\xc1\\x86.(Dr\\xc4\\x0bO\\x80\\xd3B\\x1b\\x84\\x98\"\\x0b\\x120p\\x80\\x00\\x07\\xe6p\\x12\\x0727\\xa7\\xa3\\xb33sX\\xd0B<\\xf9L\\xff\\xd1\\xcd\\x0eC\\x1fKP?\\xc2\\xb0\\x12\\x803\\xbf8\\xb3A\\x17N\\x1b\\x10u \\r0\\xe9\\x0c\\x068\\xe0@\\xcc!\\xb8\\x98B\\x01\\x18\\x9c\\x88@\\xc8!{\\xa4p\\xc0\\x13\\xc9\\xc0s\\x01\\x1b\\x9b\\x14\\xe1\\x00)\\xef\\xc4\\xd2G\\x02\\xe9\\xa8@\\xb7\\x19\\xa1\\x04\\xd1\\x07\\x06\\x02\\xcc\\x11\\t\\x06b\\xb8\\xd0\\x0b?\\x86\\xd0\\x03\\xe3\\xa3\\xfdD\\xf2\\x0b9\\t4@\\x8e\\x0e\\x12\\xa0a@-\\x9f\\x04\\x82\\r-\\x02\\x08\\x80\\x01\\x06\\x13\\xb8J\\x01#\\x9atc\\x87\\x1dU\\xcc\\xf2\\x03\\x06{ \"\\x85\\x08\\r`\\xe2\\x06$\\x1f\\\\BI:\\x88\\xebP\\x82\\n\\xb4P\\xc0\\x06\\x06J\\xe4\\xff\\x80\\x00\\x01(\\xf1\\x00\\n\\xbe\\x8b\\x82\\xf0\\x1c\\x95\\x90*\\xfc\\xe0\\x00\\xce@\\x07,\\xbe\\xb1\\x01\\x1d|#\\x0e\\x1d\\x90^\\'\\x18\\x10\\x01\\x14\\xa4@\\x04\\x18\\xd0\\x05\\x05\\xd4\\x00\\x00\\x07\\xb0\\x02X&0\\x05(t\\xc1\\x860\\xe8\\xe0\\x00\\xbfX\\xc0\\x02\\xe0\\x90\\x8e\\x8c1I\\x07\\xe98\\xc2\\x0cf\\x81?\\x0c\\xb4\\x01\\x15I@E\\x1bD\\x80\\x82>(A\\x17\\xb7\\xd0\\xc4\\x14\\xff\\x86\\x07\\x9f~\\xfc\\xc1\\x7f\\xe0\\x10\\xc07\\x96\\xa8\\x03t$\\xc0\\x0f\\x97\\xc0F\\rR\\x91\\nY\\xe8\"\\x05JH\\x1d\\x0f\\xeaQ\\x8c\\x13\\xa8B\\x19\\xc5\\xa0\\x07(f1\\x04\\x0b\\x08\\xe0x\\x0b@C:4\\xe6\\x8c5lB\\x0c3@\\xc5,P1\\x03]\\x10Cs\\x14\\xc0\\x018\\xae(\\x02T\\x98\\x82\\x08\\x9a \\xa2V\"\\xa0\\x08\\xff\\xed\\x81\\t\\xe4\\xd8\\xc07,\\xb0\\x81!$#\\x05 \\xa0\\x01\\x19dP\\t^4c\\x0f\\xbaPC+<\\xe0\\n\\x02\\x18\\x83\\x15>\\xb0\\x80\\x0et \\x859 N\\x05\\xa1\\x88\\x039\\x98\\x94\\x00\\x0c\\xa0\\x82\\x8e(\\xd0\\x05\\x0e@q\\x8b\"\\xd0c\\x07\\xdf\\xd3C<\\xc2\\xf0\\x83\\x14`\\xe0\\x10\\xf9\\xa8\\x82 \\x07\\xd2\\x0f3X\\xe1\\x00\"\\x10\\xc1\\x1e\\x94@\\x0er,\\xf2\\x1b/\\xc8@\\x04\\xde \\x03W\\xe4B\\x084\\x88\\xc0\\x0cJ\\xf1\\x06,\\xb8B\\x1beh\\x80\\x0e\\xe6\\x01\\x0bq\\xc2\\xc2\\x0f\\xb0@C\\x1c\\xd6\\x11\\x86\\r\\xd8\\xad\\x08\\xfa\\xe0K#\\x10\\xc1\\x10\\xdd0V\\x8c|\\x02\\x0ci\\x90\\xc0\\x01]X\\xc2\\x0b\\xa8\\xf0\\x83=<`\\xac\\xcbX\\x86\\x1f\\x02\\x90\\x88)W\\xd9\\x0b\\x80HA\\x1f\\xf4\\xc0\\xaat\\x08`\\x0b\\x88`\\xc2\\x05\\xc2\\xd0\\x00gH\\xe1\\x8cR\\x90\\x87 \\xb4p\\x05\\xec\\x1a\\x00\\r!\\xd8p\\x18\\x02\\xe0\\x89\\x90\\x06\\xf5\\x01\\xba\\xc8A\\xa5\\x02\\xb7\\xe7\\x86(\\xc0\\x1b\\xa4\\x88\\x82\"\\xa6\\xb1\\x855\\xd09\\xd1>\\xf0\\xc1\\x13\\xae@\\xe5B\\x14b\\x1dk\\xc0\\xe0\\x9c/\\x90\\x00K4!\\x01\\xde\\xbd\\xc0\\x11\\x10\\xf1\\x07\\x1d8\\xe3\\x1b\\xb0\\xc8C\\x07*|\\xe1s\\x04!\\xcb\\xa3\\x0b\\x83\\x12~\\xf0\\x83\\xff\\xdd\"\\n\\xdf\\xa3\\xf5n|\\xa2\\x81`\\xb0C\\x14E\\x98\\x86\\x15\\xc6\\x80\\x88\\x10$`\\x08\\xcb\\x10\\xf6:F0\\x82A\\x1c\\xe0\\x00\\x90H\\xc1\\x1e\"\\x11\\x80\\'\\x8c\\xad\\t\\x96\\x18B\\x10\\x0e\\xb0\\x06&\\xdc\\xfb\\xc9>\\x80\\x82\\xa3\\x0b1\\x08H@\\xe2\\x08\\x1c\\xf6\\x83\\x1e\\x1e\\x10\\t\\x11(A\\xc7\\xf4\\xb0\\x03/\\x84\\xa6\\xe7u+\\x04\\x18\\xda\\xff8\\x01+h1\\x8d3(\\xa2\\x0e\\xb0\\xb8\\xb7\\xa2\\x83\\xf0\\x820\\x04\\x81\\xe6\\x17\\x00D\\x08\\x9ep\\x81>\\xf4!\\x04/\\xb0\\x85%\\xfc\\xc0\\xf0\\x14|#\\xd1O\\xc8\\x02\\x95\\xab\\x9c\\x05*<\\x80\\xc5\\x90\\xf0\\x84\\x1e~ \\x82\\x07\\xb0\\x81\\x13\\xe7N\\x03\\x0f\\x08\\xa6n\\x844D\\x18\\x15\\x80\\x01\\x1e.\\xd1\\xf2iX\\x02\\x16\\xe8\\x98\\xc72\\x9e\\xf0\\x87\\xb6\\xd7!\\x00\\x07x\\xc5\\x1f\\x98 p\\x0c\\xdc/\\x0c\\xb6\\x18E(\\x10\\xd1\\x87\\r\\xe4\\xfb\\t\\xfb(\\xc4\\x08\\xbcp\\x80#\\xa4\\x80\\xe3\\x07\\x18\\x82\\x1e\\xfaPnT\\xc4\\x83\\x11\\xdd\\xe0\\x85\\x03\\xe4\\xc0\\xf5\\x92s\\xa6\\x1f\\n@@1\\xde\\x90\\x81\\x96[\\xa1\\x04\\rH\\xbb\\x0f\\xfc\\xc0v \\xbcb\\x08!\\xe8\\x03\\x06Q`\\x84[0\"\\x02\\x80\\xb0\\xc24$`>|?\\xe1\\x05n\\xb0y\\x00r\\x9e\\x827g\\xfa\\x07\\x1f7E\\x15j\\xda\\x83\\x1e\\xbc\\xa8\\xa8^\\xd7\\x003\\x14\\x96\\x06_(\\xe2\\x0c\\xa3Pd\\xda\\x15\\xfd\\x8a\\x04\\xbc\\x00\\x1c\\xe5N\\xc2\"\\xda\\x11\\x857\\xb8\\xc4\\x10q\\xb0\\x82\\xff\\xcb\\x917\\x0fa\\xb7\\xfd\\x0fA\\x08\\xc3\\x13\\x86p\\x845\\x80C\\x04\\x93XD\\x0e\\x0c\\xc1\\x83m\\x94\\xa1\\x0c\\xc6o\\xd4\\x7f9\\xd3nW\\xd0!\\r \\xd0\\x05V`\\t\\x1b\\xd0\\x00\\xf7\\x86\\x0e\\x01@u{\\xc0\\x06-\\xe0\\x02U\\x90\\x06&\\x80\\x05\\xe5\\x00\\x03\\xef\\xb0\\x03\\x1f\\xd0r\\xa3\\x10z\\xe5\\xf7\\x04lwR/\\xf0{\\x1f\\xe7\\x02\\x9a\\x90\\x06=\\xc0\\n\\xc1b ]\\xc7\\x1c\\x90\\x12\\x0c\\xb9@\\x07\\x9d\\x00\\x02q\\xd0\\x04\\xce\\xb4\\x01>\\xf0\\x00J\\xa02\\x84\\x00\\x06\\x8c\\xb0\\x03\\xdb\\xb0\\x0b\\xe5\\x80\\x00\\x1dq\\x03\\xa2\\x00\\x01y\\xb0\\x04\\x9f\\xf7\\r\\xe80\\x04\\xc2\\x06\\x0bO\\xa0\\x07\\xf0\\xf4\\x003`\\x04;\\xe8A\\xef\\x10\\x03 T,\\xc3$\\x1d\\xfdG\\n\\xa9\\x10\\x0b\\xb4\\xf0\\x02[ pl\\x80\\n{sno [\\xf4\\x12\\x0c\\x16A\\x0070\\x0e\\x05\\x90\\x01\\xe2`\\x0b\\x05x_>@\\x05\\xe0 p\\xb3\\xb0\\x08\\xb7`\\x08o`\\x021\\xb0\\x0b\\x8a\\xc2(\\x05#8Z\\x18\\x0c\\x1c\\xe0\\x015\\xb0\\n\\xcf2\\x01I\\xa0\\x0b`\\xff\\x90\\x03S\\xc0\\x0b\\xac\\x80\\x057P\\x01\\xc1\\xa0\\x00\\xc0\\xf0\\x15\\n@\\x00\\xca@\\x06\\x05\\xe0\\x0b\\xc7 \\x05R0\\x0f?\\x10\\t\\xcb4\\x0b\\x1aD\\x0f\\xed\\xd0\\x0eD\\x10\\x05\\x7fB\\n\\'\\x10!\\x98\\x18\\x11C\\xa2\\x00\\xd2 \\x84\\x92\\x00\\x02\\xb4\\x10\\t\\x91\\xa0\\x04!\\xc3\\t\\xc0\\xf5\\'\\xe6P\\x0cu\\xe5\\x01\\xe0\\x81\\x82\\x96G\\x17\\\\\\xa1\\x00\\xcfp\\x03,`\\x02\\x93\\xe7A\\xa4@\\x02\\x1c@\\x00\\xcc\\x90\\x89x\\x810\\x04\\xc0\\x0e\\xbb\\xf0\\x06\\xab\\xd0\\x0c\\x8b\\xb0\\x08\\xb8\\x10Di\\xb0\\r\\xe60[\\'`[Y\\x82\\x8dY\\x98\\x15_7\\x0c\\x08p\\x03&A[\\xde\\xf0\\x0cjX!A!\\x14\\x1a\\xb0\\x86\\x87\\x88\\x04<\\xb0\\x03\\x95\\xc2\\x0b\\xac\\x18_\\xcap\\x03\\xca\\xd0\"\\x82\\x98\\x82\\x87\\xd1\\x10\\x0b\\x19\\x0c*2\\x0c\\x13\\x82\\x90\\x19\\xe2\\x10\\x8c!\\x0c\\xcc0\\x0c\\xd9p\\x03\\x1e\\xa0\\x12\\xadH[\\x03 \\x12\\xec\\xf0\\x1d\\xb1x|\\xfb\\xb7\\x19\\x8a\\xf1\\x15\\xc4\\xa4\\xf8\\x10@\\x01\\x1b\\x9f!\\x1c\\xc3@\\x00o3\\x00/\\xc9\\x01\\xde\\xe0\\r\\x1c\\x80%\\xd7(\\x8b5\\xd9\\x1a\\x89\\x11\\x1f<\\xd9\\x18\\x18\\xf1\\x93\\x84R/\\x86\\x82\\x91Z\\xa2\\x91\\xbc\\xd1\\x1bNI\\x92\\xb1!\\x16dq%\\xc6\\x91\\x944\\xf9cY\\x89![\\xa9\\x90\\x8d1\\x1c\\x02\\xc2\"\\xb6\\x91\\x91\\xd9X\\x96\\xf0\\xe1\\x1b\\\\\\xf9\\x19z\\xf1\\x18`)\\x93.\\xa2\\x7fr\\xe1\\x02\\xfc\\xd0\\x97~\\xf9\\x97\\x80\\x19\\x98\\x82\\x19\\x98QP\\x98\\x86\\xd9_S\\x90\\x98\\x89)D\\xc2\\xd4\\x0b\\xbd@\\x04D\\xc0\\x08\\x8c\\x90\\x0f\\xb7P\\x99\\x14\\xc0 \\xa0\\x80\\x0bF\\x10\\x8f-\\xd0\\x02(\\x80\\n\\x93\\x80?\\x0f \\x02?\\x10\\x10\\x00;'", - "b'GIF89aP\\x001\\x00\\xf7\\x00\\x00\\x94\\x88\\x88\\xdc\\xdc\\xdb\\xfa\\xfa\\xfa969\\xf5\\xfc\\xfc\\xd8pqsVXBhhi-+/\\x89\\x89\\x88\\xcd\\xaf\\xae\\x82\\x83\\x8c\\xfe\\xe0\\xe0\\x92\\x9c\\x9b\\xdd\\xe4\\xe3\\xdf\\xd8\\xd9\\xc0\\xbf\\xbf\\xe0\\xd2\\xd2EHK\\xe3\\xe4\\xe5\\xe6\\xed\\xefVY_\\xd7\\xae\\xafWQX\\xfb\\x94\\x94\\xfc\\x85\\x85\\xf9\\xf9\\xf8\\xe5\\x8d\\x8e\\xc4\\xbf\\xc0#!#]fh\\xfc\\xfc\\xfc\\xfd\\xfd\\xfd\\xfe\\xfe\\xfe\\xff\\xff\\xff!\\xf9\\x04\\x00\\x00\\x00\\x00\\x00,\\x00\\x00\\x00\\x00P\\x001\\x00\\x00\\x08\\xff\\x00\\xff\\t\\x1cH\\xb0\\xa0\\xc1\\x83\\x08\\x13*,\\xe8o\\xa1C\\x85\\x0b\\x1eJ$h\\n\\xc4\\x8fb\\x16H\\x90x\\xc0q\\xde\\xbcN\\xc9&\\x8a\\xfcg\\xaa\\x1d\\x99Y\\x04?%@SG\\xa0\\xa8\\x91\\x02eH\\xda I\\x84M\\x9b\\n2\\x85\\x90\\xe4\\x00\\xa6\\xc4\\x05O\\x04\\xed\\xf1\\x15\\xeb\\x82\\x1d5\\xfat\\xed\\t\\xf6\\xc5@\\x18\\x98-\\n\\xc0\\x90\\t\\x10\\x02\\x99\\x80\\x00\\x0cs\\xd4 \\x91\"\\x070\\xf2\\xcf/e`\\x80B\\x1e\\x0f\\x1d\\xb3\\x8a\\x1f$\\x84\\xbb\\x86<\\x14d\\x11\\x05A\\xfa\\xfa\\xd3\\xef?u\\xe4\\xd2\\xc33\\x03\\x96\\xbc\\xd4\\x8f\\xd2\\xfa\\xf2c\\xb8?D|\\xdd\\xc0\\xca\\xb4\\xff\\x83C\\x0c\\xb7\\xe8\\xbb\\xc88|Jy\\xd0\\x1b\\x0c(\\x82\\xc6.\\x00Tb\\xb5\\x12\\xcf;\\x06I\\xb4\\xe6\\x95~\\x98\"kY\\x13\\x88?\\xc2Q\\x04!\\xeca \\xfe\\x10\\x83\\x1a@C\\xbb\\xc2%\\x8dk\\xff\\x88\\xc0*2P7\\x7f\\x98\\x828\\xf7H\\xc5.: \\x90\\x06l\\x0b\\x15\\xae*\\x08\\x11\\xa0\\xa0\\n\\x02\\x1c\\x80\\x0fak\\x08\\x11\\x9c\\xf0\\x01(H\\xc0\\x80\\r\\x19\\x9f)\\x0c\\xa7\\xc0\\xbcMA\\x10\\xf8\\xa2D9\\xff\\xc0\\xf0\\x92\\xaf\\xf0\\x83q\\xe3\\x13\\x80\\xca\\xde\\x90\\x82\\xd3h\\xec\\x80_y\\x9f\\x19\\x06\\xe2\\x8e2\\xb0\\xaa\\n\\x05!\\xc0%\\xfc\\xc0\\x06\\xfe\\x99\\x02\\x18\\t\\x14\\xde\\x07\\xa4 \\x81\\xa2\\xad\\xac\\x05\\xe6\\xfb\\xcaW\\xb8\\xf6\\x05{\\t$\\x1a\\xe5\\x18\\x83\\x023f>\\xac\\x1d\\x11}7PE\\xf4L\\xe1\\xb7\\x95}C\\x1bB\\x10\\xc4(\\x06\\xf2\\x80\\x0c-\\x8c \\x98\\xf8\\xc0\\x03\\xc4!\\x88\\\\\\xa4\\xac!\\xc7\\xc8\\x00\\x0cN \\x81\\x86\\xf0c\\x01\\x18\\xf4\\x8a\\xf5\\x04\\xd2\\x0e3\\x08A n\\xd8BO\\xd48\\x9f\\x1dz\\x908\\r`@\\x84\\x0e\\xa8\\xc0:\\xfeC\\x051H\\x00Ax`\\xc8\\x19\\x0c\\x04\\x1fe\\x80\\xc5-\\xc8P\\x02\\xc3\\x19Pe\\xad\\x08\\x02\\x0c\\xf0\\xb1\\x9bn`\\x12\\x82\\xe7\\xf3\\x07\\x17(p\\x80\\x1ch@\\rf\\xc8\\x81\\xee\\x8e\\x98F\\xf3\\xf5\\x83;\\x8eH\\x01\\x08\\xa6\\xb4\\xc9\\x814C\\x10_(\\x88,\\x18\\x80\\x81\\t\\xd0\\xed\\x1f7\\x18G\\xd8\\x8f\\x16\\x10`\\x1c\\n\\x90\\x9d\\xd1\\n\\xc8\\x8f\\xaet\\xe0\\x00vP!\\x94` \\x85E@`\\x1cT@\\x87.\\x00`\\x02npc\\x14 \\xd5\\xc0(r`\\x02\\x10lK\\t\\xd0(\\x91\\x00\\xba\\x91\\xc0\\x82\\x90\\x02\\x0f\\xe0h\\x87 6a=\\x1ej\\x8c\\x1f+\\xad\\x86\\x0c2\\xc1\\x03\\xdd\\xf1\\xf1\\x80i,\\xce-Ra\\x10=1\\xa0\\t\\xd1(\\x02\\x19\\xdc \\x8d4\\x18!\\x07\\x83\\xe0BT\\x030\\x08W\\xd0`\\x1d\\xcc\\xc8B\\x08>\\x90\\x01V|\\x02;\\x87;\\x9c\\xfb\\x9e\\x11\\x8d\\x0b\\x0c\\x80\\x05\\xa2\\xa3\\x9eX\\xfd\\x01\\x8c\\x00\\xb0\\x80\\x0e\\x8d\\xd0@5\\x06\\xaaV\\x02\\xda\\x80\\x1e\\x0f4H\\x14\\xa8\\x00\\x06!P\\x80\\x0c|\\xe0\\x04\\'\\xa6q\\x10\\t\\x10\\xc2\\x07\\'@D\\x08\\x18\\xc0\\x00*<\"\\x00\\x8c\\xa0\\x0fA\\x92\\xf1\\x0c\\x16\\xb4\\xe3\\xac\\x089\\x9c)\\x1a\\xd0\\xac\\x9f\\xd6U\\x87\\xbdp\\x00\\x19\\x88j\\x10_\\x90C\\x08\\x07\\xd0\\x07\\x05\\xac\\xa0\\x16,\\x10\\x81\\x08\\xc7P\\x84\\x0f\\xf0q\\x038\\xff\\xc0\\x00\\x06\\x1fH\\xc1\\x10T\\xa1\\x80+\\x1c\\xc3\\x1f\\x01\\xf8\\x84d\\x05\\x82\\x85eD\\xc3\\x1a\\x03\\xe0\\xc4+j\\x9a\\xd6~\\x08\\xa0\\x05\\xdd\\xa8\\x861\\xd5xD\\x96\\t\\xc4\\x01\\xf4\\xb0\\x84A\\xaa\\xe1\\x82\\x0e\\xac`\\x19\\x07\\x88\\x06\\x1f\\xb0\\xe0\\x06$@\\xe2\\x06\\x97\\xf8\\x00c\\xcb\\x80\\x00@\\x04\\xa1\\x18?\\x90D\\n2\\x00\\rO,\\x80\\x0b\\\\0\\x9a\\xe8\\xfc\\x81\\x85\\x03\\xb0\"\\x16jH\\xc3(\\xc2:\\x10\\x81\\x9a/\\x1b\\xd7\\x14\\x00\\x01\\xbdR\\xdd\\x86t\\xe0\\x16\\x9b0\\x886\\xb0\\xe0\\x00\\x194\\x03\\x1c\\xd1\\xb0\\x82\\x16\\x96`\\x85K\\xb4\\xf7\\x0e\\xe7\\x80\\x00,\\xa8\\x03\\x1fv(\\x80\\x03\\xb9x\\xc2s)a\\x02S\\xd2\\x07\\x0b\\x03H\\x80?\\xc8`\\x85\\xeei\\xf2\\x97\\r\\xfdG7\\xb2\\xe1A>\\x8eocl\\xf5\\xc7\\x0f\\xd4\\x80\\xaa\\x82p!\\x1f&\\x08\\x80\\x0b~`\\x84\\x12\\x14\\xa2S4h\\xd0@z\\xa1\\xb4\\n\\xf4\\x81\\x1a\\xce\\xb8F\\x00f\\xa1\\r\\x92\\x08\\x80k\\xfc\\x00F7Tp\\x80.\\x97\\xe2\\x00X(`)\\xb3F\\x1c\\xe7v\\xe3\\xff\\x89\\xf7\\xb4.d\\xc8\\x8c/\\x82\\xc4\\x02\\x0b6\\xf0\\x05.\\x02\\x91\\x88\\xa8n\\xc2\\x0e\\xb2\\xd4\\xddM5i\\x02^L!\\x00\\xa3\\xd0\\x80\\xd6Z\\xa01\\x05\\xe7m\\x0fdhH\\x02\\x04A\\x817\\x0b\\x84\\x95\\xdd\\x98OCM\\xd1\\x90\\x1d6x|\\r1\\x86\\x19\"m\\x10~\\xa0\\xc1\\x18=\\xe8\\x80\\x0b\\x8cq\\x88\\x1c\\x04\\x02\\x0ct\\x104\\xa8\\xad\\xb7\\x80M\\xf0\\xa1\\x10\\xa0\\xc6\\x1a\\x8f\\xfb\\x91\\xe9\\x7f\\\\C\\r\\xd1\\x10H\\x0b\\x96a\\x05\\xc0\\\\\\x90$*3\\x1f\\x1a5m=W:\\xb7\\x08[\\x08\\xe7Ap!\\x83B$\"\\x11\\xf9\\x18\\xc3!\\x0e!\\x86%\\xa0\\xa4\\x87\\xff\\x90\\x8f\\x06L\\xc0\\x82%\\xcc\\x86\\xc7\\x96\\xb4\\xb4)L\\x00\\x00 \\x0e\\xe4\\x05\\x03\\xe8\\xc1\\xf4\\xcaG\\x9c\\x0b\\xb2tk\\x08<\\xf6?@0\\x85\\x03\\x9c!!\\xf9@\\x83\\x0b\\x98 \\x83A\\xe0\\xc2\\x15\\xbc\\x18\\x00)\\x04\\xb0\\x803\\x9c\\xc1\\x15\\x83\\xa0\\xc1 \\xd8!q\\xbc\\xf8#\\x1b\\xae\\xe4G7\\x04\\xd2\\x052\\xe4U \\x1a8\\xc0\\n\\x9eB\\x04\\x7f(8i$\\xff\\x81\\xa2\\xd68]G\\x95y\\x02\\x00\\xb70\\x8cB\\x1cp\\x81|\\xfc\\xe0\\x02\\x85\\x80E\\x02\\xb6\\xd0\\x870\\xc0B\\x1b_\\x15\\xc0+\\xbaA\\x9c\\xd9\\x99\\xe2\\xcd\\tT\\x19#\\xfa \\x08k@\\xf0\\x1f@\\x18@\\x1f.\\xf6e\\xdd\\xfd\\xe3\\xcbY\\xb3\\xa4\\xa6\\x072\\x06r\\xa8\\xc1\\x13\\x0e\\xb1\\x01\\r\\xce`\\x8b{\\xd4\\xe2\\x1f`\\x88\\xb7-\\x07rtF\\'{eJ\\x1c\\x9f@\\\\\\xd1\\x07/\\xf0\\xf1\\xf1\\xe9\\xe9\\xea\\x92\\x8b\\x8d\\xd0\\x00\\x00\\xd1HG\\xc1\\xbc\\xbc\\xff\\xe7v\\xfb\\xff\\xfe\\xdd\\x00\\x00\\xff\\xff\\xe3\\xff\\xff\\xf4\\xfd\\xf5\\xda\\xe9\"\\x03\\x91\\x91\\x90\\xad\\xa3\\xa4\\xeeXK\\xcd\\xcb\\xcc\\xfc\\xeb\\xd7\\xff\\xff\\xf8\\xa9\\x9f\\xa2\\xd7\\x18\\x14\\xf7\\xfc\\xfc\\xf5\\x89c\\x9d\\x9e\\x9e\\x9c\\x89\\x88\\xcc\\xa0\\x9f\\xff\\xff\\xdc\\xc4\\xc2\\xc4\\xd7\\xe0\\xe1\\xf8\\xa1m\\xe1\\x00\\x00\\xfd\\xea\\xca\\xf7\\x8fQ\\xff\\xc9\\xa3\\x99\\x80\\x81\\xfd\\xb9M\\x95\\x97\\x96\\xfb\\x7f\\x15\\xa1\\x9d\\x9d\\xbe\\xb2\\xb3\\xfe\\xfd\\xf2\\xb2\\xa4\\xa3\\xfe\\xd7\\x86\\xe7\\xe2\\xe2\\xf4\\xf0\\xef\\xac\\xaa\\xaa\\xb5\\xb2\\xb3\\xf3\\xea\\xe4\\xe3\\xdc\\xde\\xe0\\xa0\\x9d\\xeb\\xec\\xed\\xe4\\xc4\\xbe\\xf42\\x08\\xfc\\x9ae\\x94\\x95\\x95\\xed\\xee\\xef\\xe6\\x00\\x00\\x96\\x97\\x97\\xa9\\x9a\\x99\\xf5C\\x00\\x93\\x95\\x94\\xa4\\x89\\x89\\xe8\\xef\\xf0\\xfe\\xf4\\xe8\\xe8\\n\\x01\\x93yy\\xf0\\xf8\\xf7\\xfe\\xfd\\xfe\\xe6\\xe6\\xe6\\xa3\\x94\\x95\\xa3mq\\xb2\\xaa\\xac\\x93\\x97\\x96\\xff\\xc6Z\\x93\\x94\\x9a\\xeb\\x82y\\x96\\x98\\x98\\xfc\\xf5\\xf0\\xa7\\xa6\\xa7\\x9e\\x99\\x9a\\xfd\\xfe\\xfd\\xf5\\xee\\xea\\xf5\\xf7\\xfa\\xfc\\xfc\\xfe\\xb535\\xe5\\xb9\\xb9\\xe2\\x1c\\x19\\x94\\x90\\x91\\xfe\\xfb\\xfd\\xd6\\xd6\\xd8\\xf0\\t\\x00\\xfa\\xf9\\xf6\\xbe\\xa5\\xa6\\xff\\xff\\xb5\\xff\\xe7\\xb5\\xf0%\\x01\\xb8\\xaa\\xaa\\xc5\\x00\\x00\\x98\\x98\\x97\\x8d\\x81\\x85\\xad\\xb0\\xb4\\xd4\\xd9\\xd9\\xf5\\xf0\\xf1\\xfe\\xfd\\xfd\\xb3\\x8d\\x92\\xfe\\xf1\\xe1\\xd6#!\\xe3\\x0f\\x00\\xceea\\x95\\x96\\x95\\xc8\\xc7\\xc7\\xb9\\xb8\\xb8\\xa4\\xa1\\xa1\\xce\\xd0\\xd1\\xf3\\x1b\\x00\\xcb\\r\\r\\x99\\x9b\\x9a\\xd8\\xd6\\xd6\\x94\\x8d\\x8f\\x96\\x95\\x93\\xef\\xf0\\xef\\x9b\\x9c\\x9c\\xfd\\xfd\\xfb\\x9b\\x97\\x98\\x9e\\x9f\\x9e\\xd1\\xbd\\xbe\\x9b\\x00\\x00\\xa7\\xa4\\xaa\\xc1\\x0b\\x0c\\xe9\\x0c\\x0e\\xdf\\xdf\\xe0\\xd6\\x0b\\x00\\x97\\x96\\x95\\xe4\\x06\\x00\\xe2\\x02\\x00\\xff\\xff\\xfe\\xff\\xff\\xfd\\xfe\\xff\\xff\\xff\\xff\\xfb\\xff\\xfe\\xff\\xfe\\xfe\\xff\\xff\\xfe\\xfe\\xfd\\xfd\\xfd\\xfe\\xff\\xfe\\xff\\xfe\\xfb\\xfe\\xff\\xfc\\x95\\x95\\x95\\xff\\xfe\\xfd\\xc4\\x1d\\x1f\\xe1\\x07\\x07\\xae\\xb0\\xaf\\xf18\\x10\\xdd}x\\xe0\\n\\x00\\xee(\"\\xf9\\xd1\\xc3\\xaf@A\\xd7\\x0c\\x0b\\xfc\\xfa\\xf7\\xf6].\\xfb\\xfc\\xfc\\xda\\xd9\\xd8\\x93\\x93\\x93\\xe3\\x10\\x07\\xfc\\xfb\\xfa\\xa9\\x95\\x95\\xf5\\xe0\\xdf\\xff\\xe7\\xe3\\xae\\x96\\x9d\\xa0\\x8f\\x8f\\xec6\\x10\\xfe\\xff\\xfd\\xfb\\xfb\\xfb\\xa3\\xa4\\xa3\\xdc\\x11\\x13\\xce\\xce\\xce\\xb8\\xa7\\xa6\\xfe\\xfe\\xfd\\xfe\\xfc\\xf9\\xb6\\xbe\\xc2\\xcb\\xc8\\xc7\\x9d\\x9c\\x9c\\xc2\\xca\\xcd\\xff\\xa7\\t\\xaf\\x9f\\xa0\\xbb[_\\xf2\\xf3\\xf3\\xfe\\xee\\xed\\xf4\\xf4\\xf2\\xf4\\xf4\\xf4\\x8e\\x8d\\x8e\\xf6\\xf7\\xf6\\x9f\\xa0\\x9f\\x9b\\x9b\\x9c\\xc3\\xab\\xab\\xf8\\xf8\\xf8\\xee\\xea\\xea\\xfe\\xe2\\xa2\\xd1\\xcf\\xd0\\x9d\\x98\\x9f\\xdf\\xaf\\xacZ\\x00\\x00\\xa4\\xa5\\xa4\\xa2\\xa3\\xa3\\xe2\\xe9\\xeb\\xca\\xbf\\xc3\\xdf\\x04\\x02\\xeb\\xeb\\xeb\\xb2\\xaf\\xaf\\x95\\x93\\x93\\xef\\xd1\\xca\\xfe\\xbb=\\xfe\\xfe\\xfe\\xff\\xfe\\xf8\\xff\\xff\\xff!\\xf9\\x04\\x00\\x00\\x00\\x00\\x00,\\x00\\x00\\x00\\x00E\\x002\\x00\\x00\\x08\\xff\\x00\\xfd\\t\\x1c80\\xd7\\xbf\\x83\\x08\\x13&\\x84u\\x80\\xa0\\xc3\\x87\\x07r\\xc5R\\xa80VC\\x88\\x072>th\\x90\\xa2\\xc7\\x7f\\xb96:\\xcc(\\x11\\xd6G\\x84\\xb0B\\x0e\\xcc8+\\x96\\xcbX\\xb9.n\\xcce\\xd2c\\xbf\\x8a2\\t\\x92\\xa4Y\\xf3dB^\\x02\\x0f\\xc4\\x82\\xd53\\xa1\\xc8\\x96\\'o*\\x9c5r\\x16\\xd1\\x7f\\xfdn)=(\\x15a\\xbf\\xa9\\x07]\\xfa\\xfc\\xb7\\xd1\\xe9V\\x8f\\xb1f\\x89\\x1d\\xfa\\xaf\\xd6\\xc1\\xabW\\xa1J\\xbdZ\\xabVU\\xac_G\\x96\\x88\\xf2\\xaf\\xaa\\xc25[\\xe0~\\x85\\x8a\\xf6\\xd6AY\\x07\\xd9\\x98\\xdd\\xab\\xf0a\\xac\\xa8\\xfdl\\xfd\\x93`\\x92\\xc2>!\\xe1\\xce\\x9c\\xd5\\xeb\\xf3VUY>\\x9e!\\x91Qb[Z\\xc2\\\\u\\xa2\\x95\\xa0 \\x85\\xb9\\x14~\\x1eL\\xba6`A\\x14Y\\xb7\\xf2\\xe4\\xc1u\\xf6\\xa0-\\xc0\\t\\x01\\xeb\\xc6\\x12/\\x18\\n\\x14\\x02L\\xfc\\xa3F\\xf9\\xa4\\xc3Y\\xa3\\x14H\\x00\\xb3\\x85\\x02\\x80F\\xe2\\xee\\x85\\x81\\x10\\x86Y\\x05\\xd8yd)E\\x9b=;BY\\xc7x?\\xff@\\xd1#\\xc6\\x11\\x08\\x10\\x86\\x19\\xd9\\xf6Q\\x16!;3v\\x18%h\\xf0\\x969t\\xa5\\x89|\\xabt$\\x0c\\x99\\tG\\x90\\x11\\x00TfE\\xc5\\xd7?\\xb8\\xc1P\\x05\\x17\\x0b\\xb40\\x891\\xc2\\x841H\\x1a\\x1f\\xc4P\\xc3 \\xae\\xe0\\xb0\\x8fU\\x07a\\xd1\\xe0\\x1f$\\xf0S\\x02H\\xb684\\xd1A\\x14\\xb4\\x81\\x0e\\x18\\xf5\\x9cp\\x84ya\\xc4\\xe0\\x9f\\x06\\x7f!8\\x95,\\xa10\\xd8B\\x0f,\\x1c\\x91\\x06\\x04\\x13P\\xf2\\xc1\\x8b\\xe7\\xf9\\x08\\xc1$\\xc1l\\x08\\x98\\x06(\\xf8\\x82\\x1e\\x04\\x83 \\xa0\\x81\\x0cy\\xe8d\\x92R\\x00\\x08\"\\x0b6\\x03\\xc4\\xf0\\xc1\\x90G|\\x10\\xc6\\x04\\x17\\x181E\\x062\\xfc\\xa3\\x0b1Z<\\xd0B/,\\xc4\\x00\\xe5+\\xact\\x10\\x01\\x0b\\x1d|)\\'\\x041\\xbc\\xc2\\xe7$8\\xfc\\xc0D\\r\\xd3\\x851\\x1dz\\x88\\xa0!\\x0bA\\xb3\\xd4V\\x97 \\x8eh\\xd2B\\x0c\\x1d\\xe4\\x19C\\x04\\x1d\\x1cq\\x84+\\x13\\x00C\\x00\\x01\\r\\xfcaL\\x85G\\xbc\\x12\\x01\\xa6\\x1d\\xb0P!\\x9e\\x1f\\xb0\\xd0\\xa3\\xa1\\x10t\\xff\\x80^\\x0c1\\x08\\xd3\\x81\",L@\\x02%\\xd3\\xa9B\\xce\\xa2A\\x9dx\\x93_\\n0\\xe0\\xc8\\x03\\xad\\xa2\\xfa\\x01\\xae\\xb4\\xd2\\x1aF\\x98,\\xdc\\xf9A\\x04\\x18\\xc8\\x83\\xa9\\xab\\xa7`\\xf0\\xa5\\x9d=B`\\xe4+\\x94L0\\xc8\\xb3\\x1d\\xb0\\x12\\x06\\t\\x84B\\xa0\\x8a\\x0e\\xa1\\xf9\\xd3hB\\x96\\xfd\\x83\\xce\\x1aZpr*\\xab\\x97\\xf6\\x18\\xa6\"\\x8axI\\xad\"w^\\x1ap\\xb6\\x9b\\x900A\\xabq\\x9e\\x07\\xa5y\\x83P\\x17F\\x1a\\x1d4\\xab\\xae\\x0e\\xc0\\xfas\"T\\x07\\xd1\"\\xef\\x16\\x1b\\xf4\\x91j\\x04_~\\tr\\x98\\x01S\\x9a*\\xbf\\xb8\\xde\\xb3\\x89\\x13\\xe0hP\\x80\\tS8\\x01q\\xb4\\x1f\\xbc\"k\\xaa\\xe6y\\x99j\\xa6a8\\xf1\\xda@\\x17c\\xacq9*0P\\xc9\\xb4\\xa8Vz\\xaaya*\\x1d\\x01\\xc0G\\xd4\\xd0\\x80\\x12\\x19\\x940bV3\\x1c\\x82L\\r\\xadV\\x1a\\x06\\x0b\\xb8\\xe6\\x89\\xb0\\xac\\x1001C\\xc5A#D\\x0b:\\xd5h\\xc2\\xc5\\x05=(\\x9d\\xe7\\xad\\x11x\\xe9j\\xb4\\x11L\\x80\\x80\\x17/\\xfc\\xffC\\xd4,2\\x1d\\x80T\\x00\\'4\\xf0A\\xa5\\xae\\xde\\xe9t\\xa5\\x04H\\x92G?A\\x15e\\xd58\\xc5\\x9e1\\x031\\x1e\\x10\\xb0\\xf3\\xe1s\\'\\xfe\\x01\\x19r\\x0cq\\x90H\\x04\\x1d\\x04\\x8d\\x11\\x13\\xf8\\xabx\\xb4q\\xc6`\\xc0?\\xda\\x84\\xd6\\x11E\\xa3l1N\\x08\\xe3 D\\xc3\\x05vV\\xea;\\xeb]\\x1c\\xd2(\\xe9\\x10\\xfd\\x13\\x0b\\x12\\x02L\\xd0{\\xb2\\xb26@\\x8c,f\\t4\\xbbB\\xb2\\xa8\\xb0\\n\\x00\\xec\\xfc\\x93\\x07\\x1b\\xb2\\x94\\xf0\\xc3=xVz\\xf8\\x07\\x13(\\x01\\x12\\xf1:\\x95\\x84P\\x06(`\\x80\\'\\x9e\\x9c\\xb4\\xe0\\xc7d\\xfe\\x1c 9B\\xb6\\xa4\\xb0\\x85\\n\\n\\xf8\\xfd\\x97\\x0cI\\x88\\x81\\xab\\xe6v\\x0f\\x01\\xc8\\x80)\\xe8\\x1b\\x88W\\x12\\xa2\\x02i\\xbcA\\x1c\\x03\\xe8E\\x1f\\x16\\xa0\\x87\\xba\\xa4E(>I\\x01>\\xb6\\xc0\\x07\\xea\\x99`\\x1a\\xacK\\xd5\\x04\\xfa\\x96@\\x82\\xa4\\xed\\x1fDH\\xc0\\x1cP\\xc1\\x83h\\xf0`\\x0f\\xff\\x18\\xc5\\xe3\\xaerB\\x85\\xe0c\\x15mH\\x01E$\\x81\\x82\\xf7\\xe1i\\x183(\\xa1\\t\\xff\\x15\\xd2\\x8f|0\"\\x01\\t8\\xc7\\x1c\\xe0\\x91\\x05Z\\xd0\\x02\\x16h\\xf9\\xca\\x16V\\xe1\\t\\x17x\"\\x197\\xa1\\r!*\\xa1\\xaam\\r\\xa3]B|\\x17B\\xf0A\\n@\\x80\\xe2\\x13\\x9fX\\x01#\\xec\\x11\\x08Z\\xd4\\xe23\\x1e\\xe9\\xc9\\x16\\x00\\x90\\x03(@\\x81\\n\\t\\x81\\x81\\x10R!\\xb6\\x0f\\x0cC\\x06@\\x11b\\xfd\\x82\\xe6\\x89\\x04\\xb4b\\x11\\x8b \\xc5\\nn\\xf0\\x88Z\\xc0\\x007\\xc5\\xa9I?\\xe6\\xe8\\x008\\xb8 \\x04\\n\\xc9\\x81\\xc7\\xc4\\x86\\x08\\x12\\n\\xd2]5\\x81\\x04&\\xce\\xd1\\x04K \\xd2\\x06.@\\x10\\x0c\\xf2\\xe0(\\x8a\\xd4d\\x14`\\x10\\xc4\\x15\\xa0\\xd0\\r0(\\xa4\\x08\"PU\\xa5\\x8e\\xe0\\x84!\\xd0B\\x90\\x18D\\x11)\\xca\\x10\\x87&\\x88\\xa1\\x13\\xbb\\xc8G\\x15\\x12R\\x9c\\x84\\xc02\\x04\\x98p\\x01\\x03X\\x99\\x90z\\xbc\\x81\\x13!\\xcb\\x95\\x1cf\\x10\\x8b0&\\x04\\x00\\xa4\\x8cC\\x1d@\\xa0\\x8et<\\xc1\\n\\x97\\xc0F\\x08\\xaa\\xf1\\x95~\\x8cB\\x05\\x82 \\xc2%l\\xc9!\\x1f\\x84\\xa3\\x17!\\xfb\\x12\\t2\\xd0\\xff\\xcd\\x12\\x8a\\xf1\\x1f\\x98\\xb0\\x81\\x18\\xc40N \\xdc\\xe1\\x0e\\xe9\\x00\\x82\\x182q\\x05L\\xbc\\xc3\\'\\xfdH\\x86\\n\\xde\\x91\\x836\\x10\\x110\\x0c(\\x06\\xab\\xbe\\xf4\\n\\x0f\\xa4\\xa9\\x84\\xf6\\xb3\\r)l`\\tK\\x94\\xa1\\tu\\xa8C\\'J1\\x8f\\x96f\\xe2\\xa5\\x1f\\x81\\xa2-\\xd8Q4\\x00H\\x80\\x88y\\xa8\\xc5\\x1e\"\\xc1\\xc7.~ \\r\\x1e\\x10]\\x02\\x83\\xb9\\n@\\xec\\xe2\\x0b\\x96(e)\\xcbp\\xd2:\\x88\\xc2\\x02\\xf4\\xb8\\xc3V\\xd0\\xd1\\x06\\xfe}\\xa4\\x83T(\\x86\",u\\xb8W\\x18\\xf0\\x1f9y\\x88\\x181\\x91\\x80\\x92\\x8a\\xa1\\tM`\\xaa\\x18D\\x01\\x02\\x10\\xa0T\\xa5\\x1eq\\xe2?\\xc6\\xb1\\n\\x15\\xdc\\xd4&\\xb5`\\xc3?\\xb4\\x90\\n\\x90\\x85,S\\xc8\\x90\\xc4\\x0e\\xbaY\"\\xc3 \\xc4\\ne\\x15\\xc3\"\\xea\\xd0\\x84/\\xd8\\xa0\\x15\\x99\\xf0\\x86(&\\x0b\\x021\\x9c\\xc4\\x1c\\x82\\x08A\\xf6>\\xd2\\x8f\\xbc\\xfe\\xc3\\x0e\\x17\\x88\\x96\\xf8\\x8e\\x90\\'D0A>i:HH\\x0cr\\xa26\\x90b\\x19\\x8b\\xd8\\x85J\\xeb\\xb0\\x0c}\\xff\\\\\\x82\\x02\\xd8\\xc0\\xc4/,\\x00\\x02Qpv\\x8a\\x9b\\xe5\\xecM$ \\x0b\\x1d \\xa3U!\\xa3\\x14\\x0b(q\\x01\\x03\\x08\\xa0\\x02g\\x9a\\xc1?v`\\x08\\x84\\xe4 \\x01\\x8b\\xf8B\\x13\\x16\\xd1\\xd6e\\x94\\xa2\\r\\x81`\\x03-\\xd8\\x01\\x00l8\\x80\\xb3\\xec\\xe8\\xdfAp\\xa1\\x18\\x85\\xe0b\\x14\\xda\\xe8G\\x07i\\x80\\x00\\x01\\x8a/\\xb9\\x9a:\\x02\"H\\x80\\x00\\x1c\\xe0\\x80\\x04\\x1e\\x80A-0\\xb1\\x02@|a\\xa0\\xa2\\xe8\\xc420\\xf1\\x0f\\xc5\\xb4\\xf7\\x1f\\xea\\xfd\\n\\x14\\xdd+\\x1bHl\\x8f\\xb8C\\xf0\\xc2\\x1f\\xf0\\x96O\\xdf\\xed\\xf2I-\\xa8\\xc28H\\xc1\\x81O\\xec\\xe2\\x90\\xa5(\\xc5.\\xac\\xa0C\\xaa\\x88\\x174\\x1e\\xc1E\\x1e\\xb4\\xa1\\r\\xa9\\xb0!\\x10\\x80A\\xc2\\x0f&q*\\x0f\\xf7QF\\xd4iA9\\x00\\xf0\\x892\\xb6b\\xa0\\xa5\\xa0G:\\x96a\\x05s0S!O\\xd9\\nY(\\xa21[\\xb4\\xb7\\x00t\\x98\\xc4\\xc9\\x94%\\xa3B=\\xc0\\x07\\x04^\\x81>HQY\\x10\\xa4\\xc3\\x02\\xe9\\x88\\xc3/\\xd0\\x91\\x90\\x07\\x1f$\\xff\\xca\\'\\xb1H\\r)\\xa2\\x8bg$\\xa1\\x06\\x02T\\\\\\x97\\xa9C\\x07\\x18\\x00\\xe2\\x13\\x1c\\xe0\\x00\\x1e\\x16a\\x89/\\x80\\xc0\\x02\\xd6\\x00B\\x19~\\x11a\\x18#\\xc4\"\\xc1\\xfcJ,L\\xc0\\x04dt\\xa1\\x06\\xae\\xe8\\xf2t\\x0c0\\x82\\x15\\x00\\xda\\x1bO8\\xaa%\\xcc\\x0c\\xd5t|\\xe1\\n\\x8dv\\xb4E\\x06y\\xbf6\\xb3A\\xaf\\xff(A\\x06^ \\x002lb\\x02d \\x011\\xb8\\x91\\x00@g\\x02\\x0f\\x1c \\xf3\\xa8-@\\xecR\\x94\\x01\\x13\\xa9\\x06MH.\\x12\\x11\\x89xD\\x1bN\\xa4E.J\\x00\\t\\\\\\x0c\\xc1\\x1dJ\\xa0\\x9a!J\\x80\\x8a^\\xf3\\xe0\\x06n\\xe0\\x00\\x0f2\\x81\\xd4C\\x13\\x1b\\x08\\x96p\\xc0]\\x1dM\\x14X\\xbc\\xc4%\\xad\\xa6HC\\x14B\\x83c\\xdc\\x81\\x11\\xd2\\x90B8\\xa4!\\x8dD@\\xa1\\x0c\\xcb\\x18\\xf6\\xb9\\xcb\\xe0\\x80f:\\xfa$k\\x91\\xca`\\xfc\\xa6\\x15S,!\\x08cH\\xc4\\x18\\x82\\x10\\x84\\rP\\x01\\x1b\\xe7X\\x86\\xa1\\x89m\\x01E_\\xe2\\xe0\\x8eN\\x0b\\x1c\\x13\\xc2\\x8eB,!\\xdf\\x89\\xafp\\xc3\\x12\\xc2\\xb1L\\x14\\xda\\xe0\\x0b_\\xe8\\x04\\xc7\\x81\\xd0\\t\\x94\\xf4#\\xbe\\x93\\xf9L?v\\xa0\\x0b]\\x8c\"&\\x90pb?h\\xc1\\x06H\\xc4\\xb7\\xb3\\xb7x\\xe3U$@\\x99,\\x98\\x01\\xe2\\xd9\\x90B\\x10\\xd4\\xb0\\x81\\x06\\xd7\\xc5\\x01$\\xdd\\x85\\xcc\\x89\\xed[\\xab\\x1c\\x1d\\x8eh\\xc1\\x05n@s\\x15\\xbb(\\xa4\\x19\\x0e\\x0fB8\\x12\\xe1\\x0c5H\\xa3\\x1d\\t\\xa9\\xc6(5.\\nz\\xd0\\xc3\\x02\\tQ:b\\xd0\\xd2\\x0f6\\xdc\\x02\\x1d\\xa1P\\x01\\x00V\\x11\\x02e0\\xe0\\xf0\\x87\\xf7\\x842\\xae\\x87\\x8f\\x14\\xb0C\\x02\\x12P\\xfaAB\\x11\\nsT\\xe3\\x11\\xeb0\\x834\\xb2\\x91\\r3\\xa8\\x01\\n\\xb6X\\xb7\\xbc0\\xb1\\x8c\\xa3n= \\x00;'" - ], - "Type": "varbinary" - }, - { - "AllowedValues": null, - "Definition": "The ThumbnailPhotoFileName column in the SalesLT.Product entity contains filenames for thumbnail images of products. The filenames typically follow a pattern that includes the product name and often the term \"small\" to indicate the thumbnail size. These filenames are generally in a GIF format and serve as references to the product's small image files.", - "Name": "ThumbnailPhotoFileName", - "SampleValues": [ - "hotrodbike_f_small.gif", - "innertube_small.gif", - "bikepump_small.gif", - "racer02_yellow_f_small.gif", - "tail_lights_small.gif" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.Product entity contains unique identifier values for each product in the form of Global Unique Identifiers (GUIDs). These GUIDs follow the standard 36-character format, including hyphens, which ensures that each value is globally unique. This column is typically used for replication and unique identification purposes across different systems.", - "Name": "rowguid", - "SampleValues": [ - "DE305B62-88FC-465B-B23D-D8C0F7E6D361", - "ACDAE407-B40E-435E-8E84-1BFC33013E81", - "E9C17BE7-F4DC-465E-AB73-C0198F37BFDD", - "0C548577-3171-4CE2-B9A0-1ED526849DE8", - "E378C2F3-54F6-4EA9-B049-E8BB32B5BDFD" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.Product entity contains timestamps indicating the date and time when a product record was last modified. The timestamps follow the standard format of 'YYYY-MM-DD HH:MM:SS.SSSSSS', which includes both the date and precise time down to microseconds. This column is used to track and audit changes made to product data, ensuring that modifications can be recorded accurately.", - "Name": "ModifiedDate", - "SampleValues": [ - "2008-03-11 10:03:55.510000", - "2008-03-11 10:01:36.827000" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.Product entity contains detailed information about products in the inventory, including identifiers, names, and specific attributes such as color, size, and weight. It also tracks financial details like standard cost and list price, along with metadata such as product categories and models. This entity includes temporal data like sell start and end dates, as well as discontinuation status. It is useful for answering questions related to product availability, pricing, categorization, and lifecycle.", - "Entity": "SalesLT.Product", - "EntityName": "Product Details" -} + "Entity": "SalesLT.Product", + "Definition": "The SalesLT.Product entity contains detailed information about the products available in the inventory. It includes data such as product ID, name, product number, color, size, weight, cost, price, and various dates related to the product's availability and discontinuation. This entity can be used to answer questions regarding product specifications, pricing, availability periods, and categorization. It also helps in identifying product models and tracking changes through modification dates.", + "EntityName": "Product Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.ProductCategory", + "ForeignKeys": [ + { + "Column": "ProductCategoryID", + "ForeignColumn": "ProductCategoryID" + } + ] + }, + { + "ForeignEntity": "SalesLT.ProductModel", + "ForeignKeys": [ + { + "Column": "ProductModelID", + "ForeignColumn": "ProductModelID" + } + ] + }, + { + "ForeignEntity": "SalesLT.SalesOrderDetail", + "ForeignKeys": [ + { + "Column": "ProductID", + "ForeignColumn": "ProductID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ], + "Columns": [ + { + "Name": "ProductID", + "DataType": "int", + "Definition": "The ProductID column in the SalesLT.Product entity contains unique numerical identifiers for each product. These identifiers are integer values with no specific pattern or sequence. This column is used as the primary key to uniquely distinguish each product within the product entity.", + "AllowedValues": null, + "SampleValues": [ + 989, + 735, + 743, + 865, + 883 + ] + }, + { + "Name": "Name", + "DataType": "nvarchar", + "Definition": "The column contains a list of product names that are available for sale. The names typically include a combination of descriptive terms regarding the product type, model, and sometimes size or color. The values do not follow a strict format but often include elements such as the product category, specific attributes, and any distinguishing features. Examples include terms related to bicycle components, accessories, and clothing items.", + "AllowedValues": null, + "SampleValues": [ + "ML Mountain Front Wheel", + "ML Touring Seat/Saddle", + "Hitch Rack - 4-Bike", + "HL Touring Frame - Yellow, 54", + "Classic Vest, L" + ] + }, + { + "Name": "ProductNumber", + "DataType": "nvarchar", + "Definition": "The ProductNumber column in the SalesLT.Product entity contains alphanumeric strings that serve as unique identifiers for different products. These identifiers typically follow a pattern combining letters and numbers separated by dashes. The letters may represent product categories or characteristics, while the numbers likely denote specific details such as size or model. This column ensures that each product can be distinctly referenced and categorized within the database.", + "AllowedValues": null, + "SampleValues": [ + "BK-M47B-40", + "BK-R50R-60", + "FR-M21S-40", + "SB-M891-L", + "FR-M94B-42" + ] + }, + { + "Name": "Color", + "DataType": "nvarchar", + "Definition": "The Color column in the SalesLT.Product entity contains a list of color names that describe the appearance of the products. The values include basic colors as well as combinations of colors, often separated by a slash. These color descriptions help in identifying the visual attributes of the products within the inventory.", + "AllowedValues": null, + "SampleValues": [ + "Red", + "Black", + "Silver/Black", + "Silver", + "White" + ] + }, + { + "Name": "StandardCost", + "DataType": "money", + "Definition": "The StandardCost column in the SalesLT.Product entity contains the standard cost values for products. These values represent the cost incurred to produce or purchase the products and are typically expressed in a decimal format to include precise cost calculations. The values can vary widely, reflecting the diversity in cost based on different product types and materials used. The cost is represented in a monetary format with up to four decimal places, indicating a detailed accounting of production costs.", + "AllowedValues": null, + "SampleValues": [ + "55.3801", + "204.6251", + "1059.3100", + "199.3757", + "9.1593" + ] + }, + { + "Name": "ListPrice", + "DataType": "money", + "Definition": "The ListPrice column in the SalesLT.Product entity contains the standard selling price of each product. The values are numeric and represent the price in a monetary format with four decimal places. This column is used to store the manufacturer's suggested retail price for the products listed in the database. Values in this column can vary widely, reflecting the varying cost of different products.", + "AllowedValues": null, + "SampleValues": [ + "404.9900", + "2294.9900", + "159.0000", + "300.2150", + "1431.5000" + ] + }, + { + "Name": "Size", + "DataType": "nvarchar", + "Definition": "The Size column in the SalesLT.Product entity contains values that represent the size of a product. The values include both numerical sizes and alphanumeric sizes (commonly used for clothing). Numerical sizes are typically in a range such as 42, 54, and 56, whereas alphanumeric sizes follow common clothing size abbreviations like L for Large and XL for Extra Large. The column appears to mix both formats to accurately reflect different types of product sizing.", + "AllowedValues": null, + "SampleValues": [ + "54", + "42", + "XL", + "L", + "56" + ] + }, + { + "Name": "Weight", + "DataType": "decimal", + "Definition": "The Weight column in the SalesLT.Product entity contains the weight measurements of products. The values represent the weight in a numerical format, which is likely measured in units such as grams or kilograms. This column does not have a fixed pattern for its values, except that they are all numerical and can include decimal points for precision. The weights vary significantly, indicating different product sizes and types.", + "AllowedValues": null, + "SampleValues": [ + "13562.34", + "8976.55", + "1050.00", + "11530.26", + "8069.37" + ] + }, + { + "Name": "ProductCategoryID", + "DataType": "int", + "Definition": "The ProductCategoryID column in the SalesLT.Product entity contains numerical identifiers that correspond to different product categories. Each value in this column represents a unique category within a predefined set of product categories. The numbers do not follow a specific format and are simply identifiers to link products to their associated categories. These categories are used to classify and organize the products into groups for better management and retrieval.", + "AllowedValues": null, + "SampleValues": [ + 39, + 28, + 10, + 27, + 24 + ] + }, + { + "Name": "ProductModelID", + "DataType": "int", + "Definition": "The ProductModelID column in the SalesLT.Product entity contains numeric identifiers that correspond to different product models. These values are used to uniquely identify and reference specific models within the product catalog. The column helps in organizing and categorizing products based on their respective models for easier management and retrieval. The values are integers and do not follow any specific standardized format beyond being unique identifiers within the database.", + "AllowedValues": null, + "SampleValues": [ + 38, + 45, + 82, + 24, + 81 + ] + }, + { + "Name": "SellStartDate", + "DataType": "datetime", + "Definition": "The SellStartDate column in the SalesLT.Product entity contains the dates and times when the products were first available for sale. The values in this column follow the datetime format 'YYYY-MM-DD HH:MM:SS', indicating the exact start date and time for selling each product. This information is useful for determining the product's availability over time and can be used for filtering products by their start selling dates.", + "AllowedValues": null, + "SampleValues": [ + "2007-07-01 00:00:00", + "2006-07-01 00:00:00", + "2005-07-01 00:00:00", + "2002-06-01 00:00:00" + ] + }, + { + "Name": "SellEndDate", + "DataType": "datetime", + "Definition": "The SellEndDate column in the SalesLT.Product entity contains the date and time when a product is no longer available for sale. The values are in the datetime format and typically represent the exact end date and time for each product's availability. This column helps in determining the period during which a product was sold and can be used to analyze sales trends and product lifecycle.", + "AllowedValues": null, + "SampleValues": [ + "2007-06-30 00:00:00", + "2006-06-30 00:00:00" + ] + }, + { + "Name": "DiscontinuedDate", + "DataType": "datetime", + "Definition": "The DiscontinuedDate column in the SalesLT.Product entity represents the date on which a product was discontinued and is no longer available for sale. This column contains date values, indicating the specific point in time when the product status changed to discontinued. If the value is NULL, it means the product is still currently available. This information is crucial for determining product availability and managing inventory records.", + "AllowedValues": null, + "SampleValues": [] + }, + { + "Name": "ThumbNailPhoto", + "DataType": "varbinary", + "Definition": "The ThumbNailPhoto column in the SalesLT.Product entity contains binary image data for product thumbnail photos. The data is stored in a BLOB format representing the image content, typically in formats such as GIF89a. The images are used for quick visual references of products in the database and are encoded in a way consistent with image data storage for efficient retrieval and display. Each entry in the column represents a different product's thumbnail photo encoded as a byte stream.", + "AllowedValues": null, + "SampleValues": [ + "b'GIF89aP\\x001\\x00\\xf7\\x00\\x00\\x00\\x00\\x08\\x0c\\x04\\x0c\\x10\\x10\\x10\\x18\\x12\\x1b\"\\x0e\\x12!\\x18!)!\\x18#\\x1e\\'1\\x00\\x00)))-%-1))1)111191111991991J99999BB99c\\x10\\x10s\\x1c\\x1ck33B9BB=FJ9BJBBZG4yx%BBJJBJFANJJRRJJRJRJJZRRJRRRRRZZNNZRRZRZRRc`WRcRZxLLk^Zc^gk^cgckkkksccoko{kk{sgskssss{sw{{{\\x84s{\\x84{{~x\\x84\\x84{\\x9c\\x8cBB\\x8c\\x8a\"\\x8e\\x83]\\x8e\\x83{\\x84\\x84\\x84\\x8c{\\x84\\x8c\\x84\\x88\\x94\\x84\\x84\\xc2\\xc2\\r\\xb8\\xb39\\xd6\\xd6\\x08\\xd4\\xd4)\\x9c\\x96x\\xb7\\xb1c\\xd2\\xd2V\\xd4\\xd4{\\x8c\\x8c\\x8c\\x94\\x84\\x8c\\x92\\x8a\\x90\\x91\\x8c\\x99\\x9c\\x8c\\xa5\\x9c\\x94\\x94\\x9c\\x94\\x9c\\xa7\\x92\\x8f\\xa5\\x9c\\x94\\xa5\\xa5\\x94\\x9c\\x9c\\x9c\\xa2\\x9c\\xa2\\xad\\xa5\\x94\\xad\\x9c\\xa0\\xa9\\xa5\\xa5\\xc5\\xb7\\x9e\\xa5\\xa0\\xad\\xad\\xa5\\xad\\xad\\xad\\xad\\xb5\\xa5\\xad\\xb5\\xad\\xad\\xb5\\xb1\\xb5\\xbd\\xad\\xad\\xbd\\xb5\\xb5\\xbd\\xbd\\xb1\\xc1\\xb5\\xb9\\xbd\\xbd\\xbd\\xc6\\xb5\\xbd\\xc6\\xbd\\xbd\\xbd\\xbd\\xc6\\xc6\\xbd\\xc6\\xc6\\xc6\\xc6\\xce\\xc7\\xb5\\xce\\xc6\\xc6\\xce\\xce\\xc6\\xd6\\xc6\\xc6\\xd6\\xce\\xc6\\xc6\\xc6\\xce\\xce\\xc6\\xce\\xce\\xce\\xce\\xce\\xd6\\xce\\xd6\\xce\\xce\\xde\\xce\\xce\\xce\\xc6\\xd6\\xce\\xce\\xd6\\xd6\\xce\\xd6\\xd6\\xd6\\xd6\\xd6\\xd6\\xde\\xde\\xde\\x00\\xde\\xde\\x08\\xde\\xde\\x10\\xe7\\xe7\\x0c\\xe7\\xe7\\x18\\xef\\xef\\x10\\xef\\xef\\x18\\xf7\\xf7\\x10\\xf7\\xf7\\x18\\xff\\xff\\x18\\xe7\\xe7!\\xef\\xef!\\xf7\\xf7!\\xff\\xff!\\xde\\xde)\\xe7\\xe7)\\xef\\xef)\\xf7\\xf7)\\xff\\xff)\\xe7\\xde1\\xe7\\xe71\\xef\\xef1\\xf7\\xf71\\xff\\xff1\\xe7\\xe79\\xef\\xef9\\xf7\\xf79\\xff\\xff9\\xde\\xdeB\\xe7\\xe7B\\xef\\xefB\\xf7\\xf7B\\xe7\\xdeR\\xe7\\xe7J\\xef\\xefJ\\xe7\\xe7V\\xef\\xefR\\xff\\xffB\\xff\\xffJ\\xff\\xffR\\xef\\xe7Z\\xf3\\xf3Z\\xe4\\xe4h\\xde\\xde{\\xff\\xffZ\\xfb\\xfbg\\xff\\xffk\\xff\\xffs\\xe2\\xe2\\x7f\\xef\\xef{\\xe4\\xe4\\x8c\\xef\\xef\\x84\\xf7\\xf7\\x84\\xf3\\xf3\\x90\\xff\\xff\\x88\\xff\\xff\\x94\\xde\\xde\\xa0\\xe7\\xde\\xa5\\xeb\\xeb\\x9c\\xef\\xef\\xa5\\xf7\\xf7\\x9c\\xf7\\xf7\\xa5\\xff\\xff\\x9c\\xff\\xff\\xa5\\xe7\\xb5\\xb5\\xe7\\xbd\\xbd\\xde\\xce\\xd6\\xde\\xd6\\xd6\\xde\\xd6\\xde\\xde\\xde\\xd6\\xde\\xde\\xde\\xe7\\xde\\xde\\xe7\\xe7\\xad\\xef\\xe7\\xb5\\xe7\\xe7\\xbd\\xef\\xe7\\xc6\\xe7\\xe7\\xde\\xef\\xe7\\xde\\xef\\xef\\xad\\xef\\xef\\xb5\\xf7\\xf7\\xad\\xff\\xff\\xad\\xff\\xff\\xb5\\xef\\xef\\xbd\\xf7\\xef\\xbd\\xef\\xef\\xca\\xf7\\xf7\\xbd\\xff\\xff\\xbd\\xff\\xff\\xc6\\xf7\\xf7\\xce\\xff\\xf7\\xce\\xff\\xff\\xce\\xef\\xef\\xd6\\xf7\\xef\\xd6\\xf7\\xf7\\xd6\\xff\\xff\\xd6\\xef\\xef\\xde\\xf7\\xf7\\xde\\xff\\xff\\xde\\xde\\xde\\xe7\\xe7\\xde\\xe7\\xe7\\xe7\\xe7\\xef\\xe7\\xe7\\xef\\xef\\xe7\\xf7\\xf7\\xe7\\xff\\xff\\xe7\\xde\\xde\\xef\\xe7\\xe7\\xef\\xef\\xe7\\xef\\xef\\xef\\xef\\xf7\\xef\\xef\\xf7\\xf7\\xef\\xff\\xef\\xef\\xff\\xff\\xef\\xe7\\xe7\\xf7\\xef\\xef\\xf7\\xf7\\xef\\xf7\\xf7\\xf7\\xf7\\xf7\\xff\\xf7\\xff\\xf7\\xf7\\xff\\xff\\xf7\\xde\\xde\\xff\\xef\\xe7\\xff\\xef\\xef\\xff\\xf7\\xf7\\xff\\xf7\\xff\\xff\\xff\\xf7\\xff\\xff\\xff\\xff,\\x00\\x00\\x00\\x00P\\x001\\x00\\x00\\x08\\xfe\\x00\\xff\\t\\x1cH\\xb0\\xa0\\xc1\\x83\\x08\\x13*\\\\\\xc8\\xb0\\xe1\\xc0z\\x0e#\\n\\xac\\x17\\x07\\xcb\\x95+f\\xbe\\x00\\x03\\x16l#F\\x89\\x12\\xeb\\xbd\\xa9a\\x8c\\xe0\\xbb7b\\xda\\tt\\x07R`\\x9e\\x16\"\\\\\\\\\\xb8 \\x13\\x08\\x10\\x0b\\x15\\\\\\xdci\\xe9\\xb0\\xde\\x96\\x033\\xee\\x94+\\x93\\xc3\\xc3\\x81\\x03;\\xd4x\\xd1\\x91\\xa6\\xa5\\xb97o\\xec\\xc41S\\x84\\x06\\x02\\x04\\x17\\xa2\\xe4\\xe1\\x87\\x8fgC6\\x03\\x00l01`\\x80\\x08\\x1c#\\x0e8\\x80p\\xe0\\x8a\\xd7\\x81\\xf3\\xaa\\xc8\\x98\\xb1e\\xe7[\\x87\\xe5\\xb4|\\x00\\x10`C\\x98b\\xff\\x8ci\\x89\\x00`\\x01\\xae\\xbb\\xff\\x86U\\x11S\\x0eq\\xc4\\xc6~\\x14(hL\\x10\\x0e\\x87 \\xdf\\x10+u,\\xf1\\r\\x9b\\x7f\"$\\x18|\\xc5\\xe8T\\xbf\\xbb>\\xd5p\\x8e\\xa8\\x86\\xcc\\xbf\\x1c\\x03\\xde\\x10\\x8c\\xb7\\xa9Q(\\xc4\\xe3\\xa0\\xf4Y\\xdd\\xb0\\x9e\\x1f\\x88v\\x0ed\\xf8\\xed\\xaf\\x9f4I\\x86d!\\xfe2D%\\xef\\x85\\xed \\n\\x0c3\\x00\\xc2\\x166}^E\"\\x94\\xec\\xb4W|\\x94\\x9a\\xfe\\xd2\\xe5|\\xf6\\xda\\xa7Pr\\x0e\\xd4\\x0e\\x87q\\x80\\x08\\xa7\\xf1\\xe3\\x84\"\\x9f\\xe0\\xf9\\xcf{\\xde\\xf1\\xf3\\x8b\\'\\xd7\\x801\\xc0\\x11\\x10\\xf1#\\x8b\"\\xb0\\xd0\\xd3O\\x8a\\x9bW\\xaat\\xda\\xf8X!\\x02\\x0cH\\xff\\xa3\\xc2\\x06e \\xcd\\xd5\\xee\\xfd\\xe0S\\\\W\\xdeH\\xa2\\n\\xbd\\x13A\\xf4\\x0e\\x0c\\x05\\xc8v\\x0f:I,\\xd2\\xca\\x9c\\x06\\xd1\\xe2\\xc99\\x1bd\\x10\\xc7C\\xab(\"\\xcb>\\xb5z\\x07\\xd1\\xbc\\xa7\\xa1\\xd5\\x1dt\\xe0\\x80\\x92\\xfc#23`\\x07\\xc7\\x1cV\\x8f\\xcd\\xfd\\xe3\\x17\\x8bP\\x06\\xd4\\xf8\\xe1@\\x81x\\xa1\\x008\\x18\\x08\\xa8\\xdc\\xe7\\x0c^\\xd4\\xc2\\x83\\x1e\\xe8\\x80\\x05A\\x08\\xc2\\x10Z`\\x04\\x15\\x88a}\\xe1\\xc8\\xc64x\\x01\\x0bT\\x84\\xc2\\x11\\x93\\x08B\\x8e(@\\x84\\x18\\xfa!hJ+\\xc3\\x06\\xa4\\x10\\xcc\\x1e\\xac\\xce\\x87\\x0c\\x8ca\\x03;&\\xca7\\x98 \\x83s\\x13\\x03\\x1an\\xd0\\x81 `A\\x02[0\\x01\\x16p\\x11\\x8bQ\\x80\\x02\\x13\\xa0\\x1d\\x85*\\x9a\\xf0\\x05,\\xc0@\\x0228C\\x0c\\x1f*\\x90y\\xb9k\\x0c\\x18\\xf0\\xfe\\xc2:6 \\x83I\\x15G \\xde\\xb3\\x07?\\x1a\\x88H\\xe9\\xbc\\x90+[\\x8b*\\x14\\x0cR\\x8e1\\xdc\\xc1\\ra\\xf8\\x01\\x14`@\\x04\\x1a\\xbc\\xc0\\t\\xa1P\\x05,v\\xc1\\rp\\xd0\\x83\\x1f\\xf2\\xf8\\x079b@\\x842x\\xa1\\x1e\\xef\\xb8\\x03;\\xdc\\xf5\\xd4\\x7f\\x88A\\x02\\xb2Q\\x81\\nf\\x84[\\xcc!v\\x8e\\x8a\\x15e\\xd2\\xba\\x90\\x011\\x18\\xc4\\x18lX\\xc70\\xcaP\\x86.\\xe4!\\x0e=\\x18\\x821\\xea\\xc1\\xcc\\xb5\\tD\\r;\\xd0B\\x19\\xc4`\\x0cb0\\xa3\\x93uT\\x17\\x06\\x1a\\xb3\\x03\\x0c\\x94\\x01v\\xa7\\x81\\x88\\xf3:\\xc9aj\\xb5c\\x08\\x13`/A\\xccQ\\x06?\\xe0\\xa1ge`*\\x11v\\x10\\x07x\\xcd\\n\\xb1\\xff(\\x07\\x0cv0\\x8crDGi)\\xf2C\\x0cR \\x9034\\x80\\x08\\x99\\xdb[\\xce\\xe6\\x88\\xc8f\\xfe\\xc3\\x0e3\\x18\\xc1,\\xdb\\xe6\\x857X\\x81\\rex\\x83P\\xac\\xa0\\x03EA\\xa4\\x8e\\xbc\\x03\\xd6\\x07v\\xb27\\x8fIG\\xb0V\\xad\\x87\\x04Z0\\xa3\\n\"3\\x85A\\x9d\\xd7\\xfe\\xdeD\\xa9\\x05\\x90\"\\xe4\\x0ei\\xb8\\xc3\\x19\\xca\\xe0\\x06/\\xe4A\\r\\x1f\\x88\\xc1!\\xc5x\\x8fv\\xb0\\x03\\n,\\x98\\x11\\xc4R\\xd4\\x0e\\x1d\\xe6a F\\xb0[\\x1b\\xd7\\xfc\\xbf\\xf74z\\x8cy\\xe8\\x01\\x04\\x1e\\x9c\\xae7x\\xa1\\x0cgPC\\x1f\\x84\\x92\\x02\\n\\xb8\\xc6\\x9b\\xe58\\x068E\\xed\\x87ax\\xf9!\\xd2a\\x03\\x0bTP\\xbdr@\\x80\\x06s\\xc8\\xe2\\xa9#\\xec\\xb0\\xa7\\x15\\xfa\\x03rKH;\\xe2\\xd0\\x0664\\xd9\\x0f\\xe7P\\x03\\x04\\x8e\\x10\\x87z\\xd8\\xb8\\x1d\\xf3\\xa8\\x87;n\\x8cj\\x1c\\x1f\\xf0\\x08\\t\\xc0\\xe3@\\xb6\\xc0\\x80#\\x90\\xc3\\xd9I#/\\xb6\\xff\\x11\\x06\\x15\\x9c\\x8c!wh\\xb01n\\xac\\x83\\x06`\\xe1\\x91\\x13\\xd46\\xd2\\xae\\x8c4cT\\xc1\\x01\\xd14\\xc8\\x0c$P\\x85c\\xc8zw\\xffX\\xf7C\\xd4 \\x03\\t`q!\\xf8\\x10\\xf1@\\x8c!\\x01\\x11\\xac\\xc19,\\r\\xa3\\xc2\\x91f\\x0e2l@\\x04\\xeb8H9R\\x80\\x01,\\xd8\\xfb\\xde\\xa2,\\x87\\x1bb@\\xef\\x99\\x1e\\xc4\\x1fm\\xd0\\x829\\xef<\\xee\\x86\\x06\\xa4\\xc0\\x0c\\\\\\xaa\\xa7\\x03\\x15.\\x10cx\\xe1\\x05\\x1f\\xb8\\x1fB\\x8c\\xa1\\x02\\x14\\x1c!\\x0f\\xe6(\\x88\\xc7\\xebq\\x0c/\\xa8@\\x04\\xb9^H=\\xbc\\x90\\x83>(N b\\x80\\x00\\n\\x8c\\x90\\x07\\xc0J\\x9c\\r=0\\x81\\x07\\x08\\'!\\x19\\xa4\\xc0\\x06U\\x18F;n\\xbc9e\\xb7cE=\\xf8y\\x15<\\x8e\\x10c7\\x1d!g\\xf0\\xc0\\x06^\\xd0\\x05\\x88\\x12\\xf9a\\xde\\x04\\xb0\\x08L`\\x82\\x8d5\\x04\\n&`\\xab\\x16\\x9a<\\x0cb\\xe4\\x01%S\\xd0\\x01\\r\\xf2.m\\xce\\xc8X\\x02\\x1b\\xa0\\x81\\x0f\\xc6\\x00Lc\\xf4A\\rU\\xa0A\\x08P\\xf0\\x81\\x198}!\\xfa:\\x01\\x0bf\\xe0\\x83\\x00\\xeb \\x07V7\\x01\\x0c\\xb6\\xd0\\xb6\\xd5\\xd0\\xaa\\x0c*\\x90\\x80\\x04>P\\x82\\xb1\\xd2\\xe0\\x03\\x18\\xc8\\xc0\\x07d@u\\x90\\x94\\x83\\xe8\\xd7\\x0b\\x81\\x08D\\xa0\\x82\\x1e\\xa8a\\xcd\\xbc\\x91\\x8e=\\xde@\\x04\\x13H\\xa0\\x01\\x12\\x80\\x00\\x06\\xb4$\\x87\\x00\"$ \\x00\\x00;'", + "b'GIF89aP\\x002\\x00\\xf7\\x00\\x00\\xd7\\xd7\\xd7\\xbe\\xbe\\xbe\\x9f\\x9f\\x9f\\xf3\\xf3\\xf3\\xe2\\xe2\\xe2\\xb9\\xb9\\xb9\\xdf\\xdf\\xdf\\xce\\xce\\xce\\xe8\\xe8\\xe8\\xf5\\xf5\\xf5\\xaf\\xaf\\xaf\\xed\\xed\\xed\\xf0\\xf0\\xf0\\xaa\\xaa\\xaa\\xa4\\xa4\\xa4\\xf4\\xf4\\xf4\\xca\\xca\\xca\\xea\\xea\\xea\\xd4\\xd4\\xd4\\xf1\\xf1\\xf1\\xfc\\xfc\\xfc\\xf9\\xf9\\xf9\\xdd\\xdd\\xdd\\xc2\\xc2\\xc2\\xf8\\xf8\\xf8\\xec\\xec\\xec\\xb4\\xb4\\xb4\\xe6\\xe6\\xe6\\xd1\\xd1\\xd1\\xef\\xef\\xef\\xe4\\xe4\\xe4\\xf6\\xf6\\xf6\\xda\\xda\\xda\\xc6\\xc6\\xc6\\xb1\\xb1\\xb1\\xfb\\xfb\\xfb\\xac\\xa9\\xa5\\x8b\\x8b\\x8b\\xdb\\xda\\xdaXXX\\xd8\\xd8\\xd8\\x8c\\x8c\\x8c\\x97\\x97\\x97\\x7f\\x7f\\x80fffooo\\xd5\\xd5\\xd5\\xd6\\xd6\\xd6\\x9e\\x9d\\x9d\\xb2\\xb2\\xb2\\xcc\\xcc\\xcd\\xbb\\xbb\\xbb\\xbc\\xbc\\xbc\\x95\\x95\\x95\\xa8\\xa8\\xa8\\xc4\\xc4\\xc4\\xeb\\xeb\\xeb\\xc5\\xc5\\xc6///FFF\\x00\\x00\\x00\\x0f\\x0f\\x0fyyy}}}\\xba\\xba\\xba\\x94\\x94\\x94LLLeee\\xdb\\xdb\\xdc\\xb6\\xb6\\xb6\\x8a\\x8a\\x8a\\xbd\\xbd\\xbd\\xb0\\xb0\\xb0\\xcc\\xcc\\xcc\\x82\\x82\\x82\\xb3\\xb3\\xb3,,,\\\\\\\\\\\\OOO\\xa7\\xa7\\xa7\\xe8\\xe8\\xe9\\x9e\\x9e\\x9e\\xd5\\xd5\\xd6\\xde\\xde\\xde\\xcd\\xcd\\xcd\\xd2\\xd2\\xd2\\xf2\\xf2\\xf2\\xe1\\xe1\\xe1\\xee\\xee\\xee\\xae\\xae\\xae\\xb7\\xb7\\xb7rrs\\xb1\\xb0\\xae<<\\xf4\\n\\xb6\\xe8X\\xa4f\\x97\\xa6u\\xca6\\xea[\\xaar\\xaf\\x1e\\xde\\x99\\xb8\\xeb\\x0b\\x03\\x8d\\xc5\\x1e-\\xab\\x14m\\xd3\\xb5P\\xddN\\x8dkus\\xcf\\xce\\x0f\\x01\\xb4`\\x81\\x80\\xa8h\\xbe\\x91M\\x03\\xae\\xac\\x9apf\\xd7&\\xedw2j\\xc1\\x97Y\\x1b\\xff\\x96\\x9e\\xf0n\\xec\\x12\\x14\\x80\\x04\\xd1>\\xba\\xaf\\xe4\\xd3\\x81-\\xaf.\\xac\\x99\\xfc@\\xeaT\\xd0\\xbf\\x18\\xc2\\x1e\\xf7r\\xef\\xf1\\xf5\\x06\\xddx\\xf6\\xddg\\x9eC\"\\x88@\\xc1\\x0b\\'\\xf4\\xa7\\\\w\\xf0\\xf1\\xf6\\x9cx\\xf5\\xd9G]\\x82\\x0b6\\xe8X{\\xb91\\xf7\\x9d|\\xbeEW\\xa0\\x81?\\x05\\x85\\xe1\\x0b^8\\xc8\\xdd{\\xbb9\\x17\\x1e}#ju\\xa0#\\'jx\\xdb\\x83,6\\x07\\xde|\\xbf\\xc5hW\\x89\\x0f\\xd5\\xa8\\xa2{\\xba\\xe9\\x08\\xe2\\x80\\x15\\x92w\\xa1\\x82|\\xd8\\x98\\xdc\\x8aE~( \\x85>\\xfe\\xc8\\x90\\x89\"0\\x80\\x88\\x93\\xdb\\x11\\xe9a\\x80\\x13\\xc2\\xe8\\xe3\\x85Y\\x88\\x01\\x03\\x97\\x1c\\xfe\\x17\\xa1\\x8b<\\x8a\\xe8\\x9a\\x1f;\\xe8\\xc0\\x03\\x0fJ\\\\\\x88\\xc7\\x1bg\\x0e\\xd9!\\x80\\x12\\xbe\\xd8#p541\\x06\\nI8A\\xc0\\x8c\"\\x98@B\\x9e\\x1b\\xfa\\x07a\\x8b;\\x86H\\xe0f\\t\\xc4\\xe0C\\x0e\\x06\\x080\\x05\\xa2\\x8a\\xc2\\x80\\x86\\x9ejBz$\\x95\\x05\\x12P\\xc5\\x19qHA\\x04\\x1bX4\\xa2\\x18\\x82\\x9d\\xfe\\xff\\x00\\xea\\xa3FN)\\xe6\\x88M\\xc40\\x81\"D\\x08\\x92\\xc3 7\\x0c\\xe0P\\r\\xb1\\xce\\x9a\\xa3\\x94a\\xfei\\x1f\\n:l%A\\n-\\x00\\xe0H\\t\\xc56\\x8ac\\x94`\\xfa\\xe9\\xa6t\\t\\xcc\\x11Cg781\\x00\\xb5$\\x00b\\x84\\xb1\\xd8\\xf6\\xd9\\xe6\\xa4\\xc0A\\x91\\x83\\x95@9R\\x06q\\x8a\\xae\\xa0\\x02\\xba_\\xaa+i\\x92\\x9b%\\x01\\x05\\xbc\\\\9\\xc2\\xc4\\xb8\\xf5\\xdek-\\x94\\xf9\\xb2\\xb9\\xef\\x88RX\\x01pCn\\xec0m\\xc1\\xf8\\xf2\\xa90\\x92#\\xca\\x80\\xc3\\xc3W\\xb4`\\xc3\\xc4$\\xd8[\\xf1\\x9a\\x91b\\\\\\xa0\\x0c$.\\x84B\\x0b78D\\xae\\xc8\\x07{iq\\xc9\\xa4\\xda\\x872\\xbc\\x07\\xb0\\xd0\\xb2\\xcb\\x14\\xc7\\xbc\\'\\xc9\\xa3\\xdeJ\\xde\\xcd?\\t\\xf0\\xf1C/\\x1b|#\\xc23\\x07\\xad\\xactD3\\x94\\x02\\nA%=\\xb2\\xa8\\xb6>\\r\\\\\\xd4\\x0b\\xb1\\x80C\\xd5=/-3\\xd0Yo\\x0b\\xdc\\xbbV\\xe2\\xd0\\xc2\\xab\\x8e\\x10\\xb2\\x07\\x170\\x8b\\xfd3\\xd6\\xc9\\x9a\\xbd\\x19\\x0e\\x85\\xa4\\x8cB\\nl\\xb3\\xff@A\\x04[$ru\\xadu\\xb3\\xbb\\xd9\\xde)\\xc7`C\\xdf\\x11\\x9d\\x90\\x9d\\xcf\\xa1\\x12\\xae\\xad\\xe1\\x87!n\\xa5\\x0030N\\x81\\xe3\\x83#;9\\xbfuY.5\\n\\x9as\\x0e9\\xad\\x9e\\xaf\\x0b:]\\x8b\\xec\\x902\\x0b\\x0f\\xbc*[\\xe3\\x8f\\xcb\\x1dy\\xea\\x0b\\xdb\\xb7F\\x0f9U\\x81\\x02\\n9\\xa30C\\x82\"(\\xa1\\xe0\\xe6\\xb5?96\\xdd\\x9f\\x8f\\x18H\\x17p\\x98\\x91B\\n>\\xb4\\x90\\x82\\x00\\xc4\\x03\\x11Q\\x1dB$\\xdf\\xe5\\xdc\\x92\\xab^\\xe5B\\x8a\\x07\\xec\\xc8\\x02d\\xe8@G\\x18\\x08t\\x9e\\xad\\xf8c*TC\\xe6\\rQaG\\x0fL\\x18A@h\\xca\\x83\\x8f\\xbb\\xc91Z\\x88\\x0fP\\x80\\x85<\\xe8\\xa0\\x07C\\x80\\x00c\\x90\\xf3\\xbd\\xdb\\xbd/w\\x01TH\\n\\x84\\xc0\\x030DAXB\\xf9\\n\\x03\\xd3\\x84\\xba\\x07\\x02pD\\x0b\\xb9B\\r6\\x85\\x17\\r\\xbaO_\\x1f,\\x10u\\x16x\\xc2\\x8b\\x89G\\x01\\x8b\\x88\\xa1\\x0cgH\\xc3\\x1a\\xda\\xb0\\x86\\x01\\xc8\\xa1\\x0e\\x8fp\\x04\\x1a\\xf8\\xd0\\x873\\x98\\x01\\x10(\\n@\\xc4Ch\\xa1\\x08E\\xf8\\xc3\\x12\\x96\\x10\\x03$ !\\x0bj\\xf8B\\x03l\\xf0\\x04\\x07\\xf4!\\rQ\\xd0\\x83!\\xdaP\\x039\\xdc! \\x00;'", + "b'GIF89aP\\x001\\x00\\xf7\\x00\\x00\\x00\\x00\\x00\\x80\\x00\\x00\\x00\\x80\\x00\\x80\\x80\\x00\\x00\\x00\\x80\\x80\\x00\\x80\\x00\\x80\\x80\\x80\\x80\\x80\\xc0\\xc0\\xc0\\xff\\x00\\x00\\x00\\xff\\x00\\xff\\xff\\x00\\x00\\x00\\xff\\xff\\x00\\xff\\x00\\xff\\xff\\xff\\xff\\xff\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x003\\x00\\x00f\\x00\\x00\\x99\\x00\\x00\\xcc\\x00\\x00\\xff\\x003\\x00\\x0033\\x003f\\x003\\x99\\x003\\xcc\\x003\\xff\\x00f\\x00\\x00f3\\x00ff\\x00f\\x99\\x00f\\xcc\\x00f\\xff\\x00\\x99\\x00\\x00\\x993\\x00\\x99f\\x00\\x99\\x99\\x00\\x99\\xcc\\x00\\x99\\xff\\x00\\xcc\\x00\\x00\\xcc3\\x00\\xccf\\x00\\xcc\\x99\\x00\\xcc\\xcc\\x00\\xcc\\xff\\x00\\xff\\x00\\x00\\xff3\\x00\\xfff\\x00\\xff\\x99\\x00\\xff\\xcc\\x00\\xff\\xff3\\x00\\x003\\x0033\\x00f3\\x00\\x993\\x00\\xcc3\\x00\\xff33\\x0033333f33\\x9933\\xcc33\\xff3f\\x003f33ff3f\\x993f\\xcc3f\\xff3\\x99\\x003\\x9933\\x99f3\\x99\\x993\\x99\\xcc3\\x99\\xff3\\xcc\\x003\\xcc33\\xccf3\\xcc\\x993\\xcc\\xcc3\\xcc\\xff3\\xff\\x003\\xff33\\xfff3\\xff\\x993\\xff\\xcc3\\xff\\xfff\\x00\\x00f\\x003f\\x00ff\\x00\\x99f\\x00\\xccf\\x00\\xfff3\\x00f33f3ff3\\x99f3\\xccf3\\xffff\\x00ff3fffff\\x99ff\\xccff\\xfff\\x99\\x00f\\x993f\\x99ff\\x99\\x99f\\x99\\xccf\\x99\\xfff\\xcc\\x00f\\xcc3f\\xccff\\xcc\\x99f\\xcc\\xccf\\xcc\\xfff\\xff\\x00f\\xff3f\\xffff\\xff\\x99f\\xff\\xccf\\xff\\xff\\x99\\x00\\x00\\x99\\x003\\x99\\x00f\\x99\\x00\\x99\\x99\\x00\\xcc\\x99\\x00\\xff\\x993\\x00\\x9933\\x993f\\x993\\x99\\x993\\xcc\\x993\\xff\\x99f\\x00\\x99f3\\x99ff\\x99f\\x99\\x99f\\xcc\\x99f\\xff\\x99\\x99\\x00\\x99\\x993\\x99\\x99f\\x99\\x99\\x99\\x99\\x99\\xcc\\x99\\x99\\xff\\x99\\xcc\\x00\\x99\\xcc3\\x99\\xccf\\x99\\xcc\\x99\\x99\\xcc\\xcc\\x99\\xcc\\xff\\x99\\xff\\x00\\x99\\xff3\\x99\\xfff\\x99\\xff\\x99\\x99\\xff\\xcc\\x99\\xff\\xff\\xcc\\x00\\x00\\xcc\\x003\\xcc\\x00f\\xcc\\x00\\x99\\xcc\\x00\\xcc\\xcc\\x00\\xff\\xcc3\\x00\\xcc33\\xcc3f\\xcc3\\x99\\xcc3\\xcc\\xcc3\\xff\\xccf\\x00\\xccf3\\xccff\\xccf\\x99\\xccf\\xcc\\xccf\\xff\\xcc\\x99\\x00\\xcc\\x993\\xcc\\x99f\\xcc\\x99\\x99\\xcc\\x99\\xcc\\xcc\\x99\\xff\\xcc\\xcc\\x00\\xcc\\xcc3\\xcc\\xccf\\xcc\\xcc\\x99\\xcc\\xcc\\xcc\\xcc\\xcc\\xff\\xcc\\xff\\x00\\xcc\\xff3\\xcc\\xfff\\xcc\\xff\\x99\\xcc\\xff\\xcc\\xcc\\xff\\xff\\xff\\x00\\x00\\xff\\x003\\xff\\x00f\\xff\\x00\\x99\\xff\\x00\\xcc\\xff\\x00\\xff\\xff3\\x00\\xff33\\xff3f\\xff3\\x99\\xff3\\xcc\\xff3\\xff\\xfff\\x00\\xfff3\\xffff\\xfff\\x99\\xfff\\xcc\\xfff\\xff\\xff\\x99\\x00\\xff\\x993\\xff\\x99f\\xff\\x99\\x99\\xff\\x99\\xcc\\xff\\x99\\xff\\xff\\xcc\\x00\\xff\\xcc3\\xff\\xccf\\xff\\xcc\\x99\\xff\\xcc\\xcc\\xff\\xcc\\xff\\xff\\xff\\x00\\xff\\xff3\\xff\\xfff\\xff\\xff\\x99\\xff\\xff\\xcc\\xff\\xff\\xff!\\xf9\\x04\\x01\\x00\\x00\\x10\\x00,\\x00\\x00\\x00\\x00P\\x001\\x00\\x00\\x08\\xff\\x00\\xff\\t\\x1cH\\xb0\\xa0\\xc1\\x83\\x08\\x13*\\\\\\xc8\\xb0\\xa1\\xc3\\x87\\x10#J\\x9cH\\xb1\\xa2\\xc5\\x8b\\x183j\\xdc\\xc8\\xb1\\xa3\\xc7\\x8f C\\x8a\\x1cI\\xb2\\xa4\\xc9\\x93(S\\xaa\\\\\\x99\\x11\\x05\\x8a\\x81.\\x17\\xc6d\\xf9\\xd0\\xe5\\xcb\\x7f3\\x13\\xe6\\xa4\\xc9\\xd0\\xa6\\xc0\\x996o\\xc2|\\x19\\xd3g\\xce\\xa0Cq\\xdeD\\xca\\x11i\\xd1\\xa5B\\x95*%\\xfa\\x14g\\xd2\\xa7T\\x7fF\\xc5XT*\\xd0\\xa8U\\xa5\\x8a\\x9d\\x9a\\xd5+\\xd4\\xa6T\\xc3\\xeeT{\\xd6\\xacX\\xac>7~-\\xbb\\x96\\xee\\xd9\\xafo\\xcbz\\x9c\\x9b\\x97 [\\xad}\\xb1\\xf6\\x95+t\\xee\\xd6\\xbfy\\xe3\\xb2\\xdd\\xc9Sb\\xe1\\xad\\x8d/2\\x8dL\\xb9\\xb2\\xe5\\xcb\\x981\\xc7u\\x18\\xd6 c\\xc6\"7C\\x04\\r\\xd8/d\\x90U\\x8f\\xa6\\xbd\\x0b\\x15/^\\xb2\\xa8\\xb3\\xaa~\\xec\\x96\\xb6Q\\xd9m;\\xfe\\x9d\\x8d{\\xe8n\\xbb\\x1f\\x7f\\x03N\\xcd:\\xf0j\\xd2\\x92\\x83\\x127\\xee\\xb6\\xf9\\xf2\\x90\\xaa\\xb5\\xb6]\\xee\\x9azn\\xc2I\\xa7\\xfa~\\xae\\xdcy\\xeb\\xd3\\x99\\xc3\\x8b\\x12\\x1fO\\xbe\\xbc\\xf9\\xf3\\xe8\\xd3\\xab_\\xcf\\xbe\\xbd\\xfb\\xf7\\xef\\x03\\x02\\x00;'", + "b'GIF89aP\\x002\\x00\\xf7\\x00\\x00z\\xa3\\x1d\\xce\\xa9E\\xf9\\xf6\\xee\\xba\\xba\\xba\\xc5\\xa2,\\x7f\\x7f\\x7f\\xb3\\xb3\\xb3\\x86r\\xf4\\n\\xb6\\xe8X\\xa4f\\x97\\xa6u\\xca6\\xea[\\xaar\\xaf\\x1e\\xde\\x99\\x18\\xefW\\xa2b\\x8f\\x96U\\x8a\\xb6\\xe9Z\\xa8n\\xa7\\xc6\\xb5\\xba\\xb9g\\xe7\\xc5y\\x1d\\x8b\\xee+\\xd9t`\\xcb\\xaa\\x0bkn\\x9d\\xf0.\\xec\\xcfz\\x1f\\x8f\\xf6;\\xf9\\xb4\\xe0\\xcb\\xab\\r\\xf3\\xfe\\xb7\\xaf\\x00\\x03\\x0f\\xd0\\xa1\\x170\\xd4H\\xb1C\\xc6\\x14\\x91\\x8dH@\\xa1{\\xf7\\t\\xe0\\xc3\\xa7\\xff\\xaa!\\x06p\\xe5\\xd4\\x843\\xf3>\\x94 \\x85\\xbf\\xf7\\xf0\\xe3\\xfbc\\xf0\\xe8w-\\x11u\\xe4\\xeb\\xd7\\xef\\x00\\x82q\\xdc\\xe9\\xb1vX\\x17\\x1e\\xbcWF\\x1cx\\xa8r\\xc6\\x82g\\xc0\\xd1\\xc7\\x18r\\xbcW\\xc7\\x02\\x105\\x81\\xc1{[\\x90\\x01F\\x1b\\x18\\x92\\x91 \\x83\\r>\\x18\\xa1?2Hp\\xde`\\x98\\tHW\\x01\\xef\\xb51\\x86\"f\\xf8\\x01\\x8a \\x82d\\x90A\\x03\\x9dd1\\xc7\\x1b`l1\\xdf\\x02\\xeem\\x01\\x06\\x1f\\xe8\\xf8X\\xc6\\x18g\\x98q\\t\\t\\x99dbF\\x1a\\xd6\\xe4\\xa3#\\x8f>:\\xf0\\xcaq\\xb9\\xa9\\x97U\\x11\\x0c\\xf8\\xb3\\xc5\\x1ah\\xf8\\xf1\\xc7 \\x051t\\x8a\\x02\\x16\\xd0\\xf1\\xc6\\x88\\xfe\\xc4\\x01@\\x16\\x81x\\xb9\\x86\"\\x88\\xa4\\xc3BG\\xfa\\xc4\\x00C\\x16z\\x80QI \\xf4\\x98\\xf1F\\x1c\\xfe\\xa4\\xb0\\x00\\x80)*\\xc7S\\x117\\xf8\\xd3F$Y\\xfc\\x91\\xc8A\\x89\\xb5PB5^BB\\x07*\\xa5\\xf8S\\x06 Ypp\\r_fAsK\\x1a}\\xf8x\\x00\\x08h\\xe0\\xb1E\\n\\x1f\\xa0\\xff\\x97\\xe8n\\x08\\x15\\xd8\\x06\\x1f%\\x10\\xc2\\xd9],n\\x01\\x88\\x1b\\xectyk\\t\\xf7\\x08G[\\x13\\xc3d\\xf1\\x06\\x87\\xab\\xbc`F\\xaa)\\xb4\\x82br\\xb4\\x1at\\xe1\\xad\\xb8\\x90\\xb9\\xebO\\x86x\\xf9\\xab9\\x06\\xe2j\\xc3^\\x90\\x91\\xe6\\x040n\\xbc\\xf1\\xaa\\x01.^zS\\x82+\\xae\\xfd\\xd4\\x88{c\\xb8\\x81\\x8a,\\xef\\x01R\\x82\\r\\xa1\\x91j\\xae\\x14\\xc0\\xe4\\xd1\\x87?;\\x84\\xe1\\x02\\x1dk\\xf8SA\\xbcZ\\xee\\x94\\xdf\\x1anh\\xcb\\xd3V\\x17\\xcaAG\\x06\\x02t\\nF\\x16(\\xc8f0qU\\xa83\\x07\\x18\\xfeH F\\x00g\\xd8\\xe1\\xcf\\x0cY\\xaaxP\\x0f\\x9e\\xa6!HV?\\xcd\\xf2^9\\x8c\\xf0s\\x87\\xa7h\\x14\\x93\\x80\\xc9\\xe5\\xa2\\xdc\\x0b\\x01\\xacl!\\x83\\x18\\xca\\x98\\xb0\\x87?\\xd2\\xd4\\xac\\xa8A\\x8dfS\\xc2\\xa4\\x881t!\\x19Y\\xac\\xc0O\\x81\\xfdR\\xe3O\\x18\\x05\\']\\x1b\\x16\\x1a\\x98\\xc1\\xf2*_p\\x83\\x06\\x19\\xfe\\xfc\\x10\\xe0\\xd5\\x04\\x1d\\xe2%\\x1a;\\xf3\\xff\\xccP~\\x92\\x04\\xad\\xc6{\\xf1\\xb8\\x81\\x87?#\\xa4=\\xdc\\xda\\\\<\\xf0\\x86?\\x9a|q\\x0c\"l\\xf8\\x83\\xc0\\xdd\\xd5\\xfe\\xc3\"\\x19n\\xe0\\xeb\\xb7BSx:G\\x0b\\xfc@\\xe0\\x8f\\x1cy\\xe0\\xa0\\x87?7(~\\xec_\\\\\\xe8\\x82F\\x84VD\\xd1\\x0e\\x1cN\\xdf1\\xebN\\x05B\\xe2H]\\x0cm\\x9e\\x85\\x00\\xfct\\xb9\\x86\\x05\\n\\xa0!\\xb3\\xeb\\x91\\x95v\\x129y\\xb0\\xdcC\\x14\\x17\\xa4A\\xb7\\x01\\xbb#\\xe4\\x1e&\\x11\\x00\\xbf\\x90\\xf1\\x9d8\\xd4\\xa8(\\r\\xfc\\xe2\\xb6?\\x03\\x90\\xbb\\xb8\\xf3(\\x99P\\xf9\\tQ\\x18\\x13\\xbd?\\x10d\\x7f\\xd0{h\\x10\\xe3\\xbdB\\x05\\x8e\\x124?\\xef\\x01@(\\xa8\\x90\\x85\\x88\\xa5\\xcfX\\xcd\\x83]\\x17\\x0205\\x15\\xb8$\\x0b\\xef\\xb3_A\\xba\\xf0\\x9e4\\xe8\\x8a.\\x0c)\\x10)2\\xe0\\x10\\xfc)\\x80\\x80\\x95\\x13\\x81\\xfa^W\\x9c\\x00P\\xc2\\x1f\\x0ep\\t\\x01*\\x97\\x00\\t\\x12\\x84^\\xfe\\xb0\\xe0\\xfe\\xfa\\xa1A\\x0e\\x020\\x869\\x00\\xa1?D\\x88\\xc0\\x83\\x99\\xc6\\x84(tI\\x00\\xffX\\xe8\\xc2\\x81\\x14\\xa1\\x82\\x93\\x98a\\x81\\xc8\\xd7A\\x7f\\x9ca\\x80Y8\\x1c\\x0fg\\x93\\xc0\\x12\\x9e0\\x85Sp\\x03\\x11\\xa9\\xb5\\x93\\xf7\\x9c\\xa1o\\x9f\\xa3\\xa1?\\xf0\\xf0\\xbf\\xf7p/\\x19\\xf3; \\x15}\\xa8\\x96\\x07T\\xce\\x81S\\xc8\\xc2\\x18\\xfcq\\x82\"\\x0e\\xc4=\\xa3\\xa0\\xc1\\x0c\\x13\\xe0\\x0f0\\xf8A|\\xfe\\x80\\x04*r`=\\xf4\\x8d\\xb0\\x8aMaF\\x14\\xe9\\x18\\x05^\\xd0\\x81e\\xf5\\xe3b\\xad\\xfc\\xb1\\x06?\\xcc\\xd0tv0\\x83)\\xf8\\xc1\\xc78\\xb8\\x81\\x03g(\\x83?\\x98\\xc7F.h \\r\\x84\\x9a\\xde;\\x14!3\\xecI\\xf2 \\xa6k\\x03\\x1d\\x92\\x18\\xc6\\xd0\\xf9\\x03\\x00\\r\\xe0\\xc7#\\x1c5\\x87fL\\x8d\\x02\\xa4D\\xd9I^\\x00\\x07Q\\xb6\\x84\\x00\\x8f\\xd3\\x01\\xe6vBA\\x7fD\\x02\\x14\\x18\\xfc\\x9b?\\xc6\\xe0\\x07\\x01,\\xe1=\\x92@\\x04\\xcb\\x12wH6:\\x03\\x82\\x90\\xfb\\xc2\\x05\\xcc\\x10\\xb1\\xcb\\xd9q \\x05\"\\x83\\x19.\\x98\\xaf\\x85\\xb0\\xa8\\x0ch\\x88@\\xf1\\xfc\\xa1\\xce89!\\x98k\\xdb\\xc6\\x19\"\\x04\\xff7y\\xe8A\\x94v;\\xe7?p\\xe6L\\x0bpmc\\x0c\\xd9\\xd74\\xdd`\\x8a\\xa1\\xf9\\x03\\x10\\x96\\xf0\\x05\\xd2\\xd6\\xc7\\x14\\x14\\x80\\xf3i\\xcfHC\\xc4\\xbaa\\xb5\\xcc\\xa1\\xd3\\x1fv@\\x83\\x1e\\xdb\\xe9N/\\xf1\\x01y\\xd3p\\x94\"P1Q\\x12F\\x03\\x04\\x8b\\xe0\\x90\\x04\\xd6\\xe1\\x86M\\xf8h\\x01\\x1d\\xed\\x89\\xde(i\\x86?\\x90T!\\x8d\\xc8\\x8f\\x1c\\xd0\\x90\\tI\\xbc\\'\\x0eih\\x00>G\\x12\\x0c|\\xc0\\x81n\\x0eX\\x06Le6\\xb1\\x9c\\xf6\\x84E\\xd3\\xec\\xe9A{\\xf3\\x13[\\x92\\x01\\r\\xf3\\x80\\xc7{\\xc6@\\x07\\x0e\\x8c\\xa3\\x87g\\xd1\\x06\\x08\\xe00\\xc7\\x14\\x9c\\xc3\\x04O\\xf5\\x87\\x0e\\xa6%/\\xac\\xf0q\\x9asp\\x04;\\xcb\\xb4\\x95D\\x1c\\xe0=d\\x80\\x83%\\xe24M4X\\x80\\x16k\\x0cI..\\x01\\x87\\x88U\\xa2\\x1eYX\\x04\\xddR \\x04\\xbaV\\xac\\'w\\x8d\\x03\\x1c\"\\xa5\\xb1\\x81\\xfcD\\x00\\x19(\\x01\\x1aX\\x06\\xd27\\x98\\x81\\xb0d`E\\x16H\\xc0\\x82r\\xc5\\x00\\x07ix\\x03\\x19*\\x11\\x0bK\\xff\\xcca\\x0f\\x1c\\x82\\x95\\xac^iW\\x03\\xb1\\xe1\\x0cypD\\x04&A\\xa6~\\x9cb\\x05\\n\\xa0\\x81\\x1b\\xd0\\xc0\\xa3\\xf8|I\\x0f\\xdf0\\x10\\x92\\xcc\\x80\\x03w\\xd8#\\x1d\\x97\\xa0\\x03\\x1c0\\x01\\x0ba b\\x0e\\x8b\\xe8\\x11\\xc3\\x0e\\xb5\\xdb\\xba\\xd2\\xa5\\x07\\xeeq\\xd4\\x18\\xdep\\x864\\x98!\\x0bY\\xc8C\\x1a\\xd0\\xa0\\x87=\\xc4\\xc1G\\xfe\\xc0\\xc0\\x1d\\xf2\\xe3)0\\xac\\x01\\xbfG\\xdaD{\\xdf\\x0b\\xdf\\xf9\\xd6W\\xbc\\xf3\\xd1\\x02\\x96\\x96y\\x98\"\\xdc\\xf5=v\\x88\\x03\\x18\\xc6\\xc0\\x865\\x80A\\x0e\\xa2|\\x8f\\x07\\xee \\x94\\x02\\xa4\\xd7S\\xf2i\\x83\\x84)la2d\\x18\\x85\\xd88\\x11\\xc5lV\\x97.`\\x80\\xbf\\xfb)T\\x02\\x88\\xf0\\x9b]p\\xa2Q1\\x8e1\\x02>\\xf0\\x9f\\xf2^\\xb65\\x87\\xe8A\\x01\\xa2\\xe3\\x01\\x0c\\x14\\x80\\x08\\\\\\xf9\\rX\\xc2\\xe0\\t\\x110\\xc0;*\\x10Gx&\\x10\\x8eT\\x18\\xc26*\\xb6\\xear\\xb8\\xca\\x10\\xcf4f\\xa9\\n\\xbc\\x8d\\x8fY\\xbce\\xbb\\xfc\\xc4\\xcb\\xa0\\xe9\\xa60)\\x83\\x1a\\xcb\\x92yY\\xcb\\xaf\\xb9Nl\\xc0\\\\\\x1c1\\xbb\\x19op\\xf6\\x8d\\x9c\\x81\\xd3RD\\x9a\\xa7\\xcd+\\xee\\xc1\\x10\\xf6A\\xe8B\\x1b\\xfa\\xd0\\x88N4\\xa2\\x89\\xc0\\xe8F\\xdf\\xe1\\x0e\\x85\\x88t\\xa4\\x07@i\\x1fX\\x1a\\x1c!\\xc8\\xb4-\\x0c\\xc0\\xe9O|\\xc2\\x10\\x0b\\xf0\\xc4\\x0f>\\xd0\\x8a l`\\x03\\x8f\\xe0D\\x07:0\\x83\\x1a@ \\x00;'", + "b'GIF89aP\\x001\\x00\\xf7\\x00\\x00\\xe3\\xe3\\xfc\\xb8\\xbb\\xc8\\xac\\xad\\xb0UUZo\\x83\\x8f\\xf9\\xfa\\xfd\\xf4\\xf6\\xfe\\xed\\xed\\xfe*FS\\xe2\\xe5\\xea\\x9a\\xa6\\xb3Ml\\x86\\x99\\x9b\\x9e\\xcb\\xd0\\xd5\\xdc\\xe2\\xeb\\xbb\\xbd\\xbe\\x87\\x8b\\x93\\\\fs\\xd1\\xd1\\xd3\\xf9\\xfa\\xfa\\xc5\\xc9\\xe3\\xe9\\xe9\\xfd\\xdc\\xdc\\xe9gku\\xdc\\xde\\xe2\\xaa\\xab\\xad;\\x84\\x87\\x8b\\xb2\\xae\\xae\\xc7\\xcb\\xd5\\xea\\xeb\\xfaegl\\xfa\\xff\\xff-/5\\xf3\\xf4\\xf6_}\\x8ey\\x9e\\xb3\\xc0\\xbf\\xcb\\xf2\\xf3\\xfboz\\x8b\\xfd\\xfd\\xfa\\xf3\\xf8\\xfaAFh\\x91\\x9f\\xaf@[\\x90\\xef\\xf0\\xfb\\xe4\\xe3\\xe6\\xe3\\xe4\\xf2\\xf2\\xfa\\xfd\\xb5\\xb7\\xb6\\xec\\xea\\xeb_^c\\xf4\\xf3\\xfe\\xed\\xee\\xf7\\xeb\\xec\\xf1\\xb7\\xb8\\xbawz\\x7f\\xd7\\xd9\\xe8\\xe5\\xe7\\xe8\\x8d\\x8e\\x91\\xf0\\xf2\\xfd\\xe8\\xe9\\xe786?C\\xa7\\xa7\\xaa\\xfd\\xfe\\xfe\\xfe\\xff\\xff\\xfd\\xfe\\xff\\xfb\\xfe\\xfd\\xfd\\xff\\xfe\\xfc\\xff\\xff\\xfc\\xfe\\xff\\xfc\\xff\\xfehgg\\xfe\\xff\\xfc\\xe2\\xe4\\xf6\\x9e\\x9c\\xa8\\xf1\\xf1\\xfe~\\x7f\\x83\\x9c\\x9a\\x98yu\\x82\\x9a\\x97\\x97nw\\x80\\xaa\\xa6\\xa7\\xc7\\xc8\\xc7\\xf8\\xfe\\xff\\xf9\\xfb\\xfe\\xfa\\xfd\\xfd\\xec\\xeb\\xf3\\xea\\xec\\xf7\\xd1\\xd7\\xe0\\xeb\\xeb\\xf3\\x8f\\x90\\x8e|\\x8a\\x9ea\\x7f\\xb7k\\x85\\x9f\\xe6\\xe6\\xf9\\x9d\\x9f\\x9a\\xf9\\xf8\\xf3\\xde\\xde\\xe0\\xf1\\xf3\\xf2rps\\x1f \\'W_xM`}\\xa7\\xa8\\xa6\\x8a\\x84\\x86\\xf7\\xf7\\xf6uro\\xe9\\xe6\\xe6fx\\x9c\\xef\\xef\\xf0[j\\x95\\xf3\\xf3\\xf5\\x1aDm\\x1d?Upmp\\x8a\\x98\\xa7\\x84\\x8a\\xa9\\xc5\\xc4\\xc6\\x9f\\x9f\\xa2\\xfc\\xfd\\xfb|{\\x89\\xee\\xee\\xea\\xfd\\xfd\\xfexyx\\xa1\\xa0\\xa0\\xfb\\xfb\\xff..3nx\\xa5\\x96\\x97\\xa6\\xe1\\xd7\\xd5\\x84\\x97\\xc0\\xc1\\xc1\\xd7uz\\x98\\xd7\\xd7\\xef\\xd6\\xd6\\xf8\\xd1\\xca\\xc6\\xff\\xff\\xff\\xfc\\xfe\\xfe!\\xf9\\x04\\x00\\x00\\x00\\x00\\x00,\\x00\\x00\\x00\\x00P\\x001\\x00\\x00\\x08\\xff\\x00\\xff\\t\\x1cHp`-\\x7f\\x08\\x13\"\\xace\\x0ba\\x9aq\\xfer\\x15\\x9cH\\xb1\\xa2\\xc5\\x8b\\x18)\\x1eT\\xa8p\\xdc\"y\\xbdbx\\x08b+\\xa3\\xc9\\x93(+n\\xe4\\xd8\\xf0\\x8f(\\x10+\\x0c\\xb9\\x91\\xe0/\\xa5\\xcd\\x9b\\x18W*\\xb4\\x05\\xef\\x08\\x1ftZ\\\\I\\xa9\\x99\\xb2V\\xad\\x7f\\xb8\\xfe\\x1d5\\xca\\xb4\\xa9Q\\x9c\\x16urD\\x18\\xca\\xd8\\x92\\t%S6\\x9c\\xca5!T\\x95]\\x116<\\x13\\x81\\x9d?^\\'\\x19\"\\xfc\\x84\\x02\\xc5\\xa7OW0aRA\\x92\\xe3W\\x8da\\x13\\xb2\\x12\\x05\\xc5\\x96D\\x93\\x1b\\x85l\\t#\\xc9E\\x8f\\xc3=\\\\\\xb8p`\\xf7\\xeeD\\xa7N\\xfdM\\xc0!j\\x07\\xd1\\x93\\xb6\\x96\\x11\\xc1\\xe2\\xef\\xdb\\x872\\xe7\\xce\\x81\\x99\\xc4(Hc\\xc7\\'\\xfduH\\x04\\xe5\\x96.\\x9bR\\x15\\xb8X0\\t\\x13W\\xd4\\'s\\xf9\\x13S\\xc4H\\xc2\\xbf\\x19k\\x8d\\x18\\xd8\\x90\\xcf\\x8fPaqc\\\\\\xb6\\xcc\\xd6\\xae\\x05`\\x12\\x11\\xe2\\xd0\\xe17\\xae\\xa4*\\x8f\\n\\xf4\\xe7\\x07\\xc8\\x87\\x85J\\x13\\xda\\xff\\xca\\xaa\\xbc\"\\xaee\\xfe\\xd6\\xb8\\xe0\\xb6M[\\x88/\\x03X\\xac\\x11\\xaf\\xfd\\xf1\\xf6\\x07\\x1ep\\\\\\xf3\\x97ue\\xfd\\xf2\\x16\\xf9\\xa3\\x00\\x18\\x88(\\x91E\\x06U|\\x11\\x826+\\x00\\x91\\n}\\x15\\xf9\\xa3I\\x11\\x03L\\x80\\x10\\x806\\xf9\\xa3Bau|!\\x0cB\\x9d\\x98\\xa1\\xc5{\\x90\\x18r\\x06\\x13\\xe2\\x19t\\xd0\\x04\\xd0}w!\\x86\\xb9a!\\x80\\x16\\xc6\\xf8cF\\x08P(\\xb4A\\x08\\xef\\x85\\x00B\\x12\\x1e@4\\x953\\xe6,\\xe0\\x87W0f\\xc4\\x8b?\\x10Hb\\x88o\\xfe\\xdc\\x10B\\x0c\\n]0\\xa5\\x12-\\xf0\\x08\\xc9\\x05\\xa6\\x94\\x93P\\x10\\x04\\x9c\\xa3\\xc0eIb\\xd4P8\\xc6 `\\xc4\\x03\\xfc\\xf9\\xc3A\\x08J$\\xe4\\xcc\\x17\\x1a\\xf8s\\x85)\\x86\\xb8\\xf7\\xc5\\x1eq\\x98\\xe0\\xcf\\x0eE\\x14q\\x02\\x99e\\xfe\\xb3\\x15G\\x91L K\\x0f\\x04\\xbc\\x88\\x10\\x03!\\xa8\\x92\\x90%!\\x00\\x91\\x90\\x1d@\\x0c\\xa0\\xe0\\x17e$\\x92\\xc7\\x0c\\x0f\\x16t\\xe8T\\xc0\\xa5\\x84\\xd02|\\x94\\x90\\x01\\x03f|\\xf0\\xc0\\r?0\\xff\\x80@\\x03\\x97\\x91\\x81\\x10\\x0e!\\x98\\x81\\xd0\\x9c{\\x14\\x10QB\\xd7\\xdc\\xa0\\x85{+\\x98R+B\\xf0\\xa4R\\xc2\\x19\\xac\\xb2p\\x82\\x04\\x9c\\xf9\\xf3\\x1fF\\x08I\\xc1\\x80!Z\\xec\\x01\\x826\\xdc\\x82 J6\\x10\\xb8\\xa0[A\\x08\\t\\x13\\x02\\x07\\x08E\\x13\\x82Y\\x03\\xe9\\x86\\x90\\x19_\\x9c\\x12\\xaa\\xa1\\xfe`\\xe1\\xc1\\x0c\"\\xe4\\xd1\\xca\\x1e\\xf4\\xb4\\xe0C\\x1e\\x03\\xfc H\\x16\\xd2f\\xe4O\\x17\\xaa\\xb8\\xe1C\\x0b{h\\xe0\\x86\\x08n\\x102\\x8b\\x088\\x84\\xe1\\xc2\\x0f5\\x90i\\xab?N\\xe4\\xeaO\\x1bE\\xb4p\\x05\\xa1\\xfe\\xc8\\x01\\xc9\\r\\x05l5\\xc1\\t+\\xec\\xd1\\x02=\\x89\\x94\\xf1\\xb0\\x08Z$\\x02\\t$edcY\\xa9\\x05\\xe9V\\xc2\\x00\\xff\\xbaaH\\x0c\\xad\\x02q\\xcc\\x1f\\xe0\\xc0R\\x8c<+hS\\x86\\x9f\\x7f\\xb9[r\\x08,\\xf8\\x93N\\x08\\x0c\\\\\\x86^\\x13\\xdaTaL\\x00\\xa80\\x92\\x06\\x14y\\xd0\\xd3\\xca\\n\\xc2tc\\x02%\\xeb\\x04`\\x8a\\x18qT\\xa1\\x81\\x0fZ\\xdc`!E\\xba\\t\\xe0F\\x1en\\xc4\\xff\\xc1\\xc0\\x03:4\\x11\\xc4(\\xfe\\xa4\\x10\\xc7\\x00\\x7f\\x0c\\xe3\\xca, \\xf8\\xf0\\x9dD\\x87\\x8e J\\x08g$\\x93\\x08\\x08\\x91\\\\\\xe6\\x8f\\x07_l2\\x88\\x13\\xd0\\x90\\xa5\\x01\\x08\\x030 \\xc1\\x18\\x9c\\xf8\\x03\\x03\\x08\\x93y\\xcf\\xfe\\x00\\xa1E\\x1e+\\xac\\xd9\\x01\\x19l 1\\xc1*\\xfeX\\xe0\\x817\\xe8\\xfc\\xf1\\xc0\\x0fU\\xec\\x01\\xc9w\\xed\"t\\xc4\\x00!\\xc8\\xb2\\xc4\\xb9\\x9a\\xaf\\x00\\x89\\x11\\xf5L\\xa3A\\x19\\xf4\\xc8\\xcd\\x02\\x150\\x14P\\x81-h,S\\x81\\xfa\\xfe\\x18\\x80\\x8a)\\xc2h\\xa0A\\x1c#\\x13\\xe4O\\te\\xe4a\\x08\\x10\\x8c\\xcc\\xf3M*\\x06\\xe0\\xc1\\x04\\xd8\\x90\\x0b@\\xb0B\\x1f\\x99\\xd8A\\x14R`\\x86\\x15\\xf8\\xa0\\x15~\"\\x83@\\xdcu\\x05\\x11\\x84@\\x01\\x99\\x00A\\x13\\xfc\\x81\\x9eRhc\\x00%X\\x02\"\\x16\\x90\\x08\\x1f\\xc0\\xc2\\x12\\xd1p\\xc6\\x01`\\xf0\\x86\\x7f\\xa0!\\n\\x15\\xa0A\\xfa*\\xe0\\x8fRP\\xe2\\x06\\xb3\\xc8\\x83\\xa4^\\xf3\\x0f\\x7fXa\\x00\\x1a0D\\x06\\xff0\\xe0\\x8f\\n\\x14\\xa0\\x0b]\\xa8\\xc0\\x15`\\xb0\\x0c6XA\\x0f\\x9a\\xe8\\x03 \\xfc\\x11\\x8b\\x06\\xd2C\\x04V\\xb8\\xccV\\xca\\xa1\\x85/d\"\\x047\\xf0\\x07.r\\xf7\\x05\\'\\xb0\\x82\\x06\\xdcxA\\x0f\\xca@\\x88$\\xd4\\xc1\\x01\\xf0\\x00\\x005\\n\\xf0\\xc2\\n \\x01\\x061\\xa4\\x01\\x1b&`\\x03E\\xc8\\xcfO\\xdb\\xc1\\xc1\\xc4hA\\x024\\x14\\xc0|Y`\\xc5/\\xa8p\\x00e\\x8c\"\\x00/\\xa0\\xc0(j\\x91\\x8by\\xc8\\xc0\\x0c\"\\xa0\\x07\\x0e\\xb4\\x98\\x90\\'\\xe4AA\\xda\\x10R\\xf3t\\x85\\x0cBx\\x0e\\x03fH\\xc4\\x0f\\x1a\\xd0\\x06\\x03\\xf0\\xc3\\x00\\x8dX\\x06\\x1a`0\\x05$\\x18\\xe0\\x00\\xed\\x00\\x84\\'L \\x87=\\x88\\x02+\\xe9\\x19\\xc0,\\x14\\xe1\\xa7 \\x00\\x80\\x062<\\x02*\\x1aa\\xc8`\\x88\\xe3\\x05c\\x88H!`0\\x02J\\xfc \\x11Z\\x18\\nq\\x12b\\x85V\\xf0\\x08\\x02\\xfeP\\x836\\x08\\xc1\\x82 \\xcc@\\x03\\xdc\\x90\\x06\\x11\\xfc\\xc1\\x88*\\xb8A\\x01m\\xa8@#\\x0e\\x10\\x054\\x00\\xa0\\x11\\x06\\x80A-\\x0ep\\xff\\x00\\xd5|@\\x0b\\xf4`\\x93?X\\xa0\\x85\\x01\\x08\\xc0\\x02h\\xa0\\xc1\\x11\\xa8a\\x80J\\xb0\\x01\\x0b\\x168\\xc0<(\\xb0\\t\\x05\\\\\\xe2\\x1fl\\x80\\x01\\'`0\\x8e\\x0c\\x0c\\x80\\x1e\\xec\\x12\\xc8\\xa8\\xa4\\x90%m\\x14\\x80\\x05\\xda\\x10\\x816 \\xa1\\x8d/\\xcc\\x02\\x11\\xe4X\\'\\rXP\\x86\\x19\\xac\\x01\\x00h\\xb0\\x05\\x00\\xa6@\\x05N\\xe4\\xe2\\x00\\x04\\xb4C(J\\x80\\x0e\\x10\\xc4A2r\\x98E\\x0cJ\\xe0\\x0f\\x1aT \\xa1\\x8d(\\x04\\'\\x0c\\xd0\\x01<\\xf8\\x03\\x1f\\x9b\\xa0\\x15?\\x0f`\\x00[d\\x81\\x121\\xd8\\x83#r\\x01\\x9c\\\\\\xa8E5 \\x00\\xa3!|\\x80\\x03\\t\\x18\\x02\\x04\\x89\\x18\\xdd\\x17\\xb4\\xa1\\x85\\x0b\\xd8\\x83\\x03\\x00[\\x82\\x0cR1\\x85)\\x14\\xe2\\xa7\\x80P\\x01+\\xb0\\xe1\\x8fk0\\xc0\\x84VH\\xc3\\x00\\xdc\\xc0\\x80\\x14\\xdcb\\x1e\\xf00@\\x05rP\\x016\\x00\"\\x01:@\\x854\\x06\\xd1\\x016\\xa0!\\x18\\xf9\\xbcC R\\xc0\\x00-\\x10\"c\\x13\\xb9\\x05BHP\\x85\\x0b8!\\x06bH\\x80\"\\x08a\\x08A\\xffH\\xc0\\x03\\xaa\\x90C\\x19Z\\xb0\\xad/TA\\tg\\xa0@#\\xfcq\\x80F\\xd4`\\x0cT\\x00\\x04\\x0c\\xca\\xe0\\x0f\\xeb\\xc0\\x02eS\\x1d\\xba\\xe0\\x0f\\xf1 V\\x02 \\x01o\\xd0\\x04\\xb6\\xa0\\x06XP\\x03\\x9c\\x00\\x08o\\x80\\x04\\x8d`\\x05j\\xe0\\x07O0\\x04Q\\xe0\\x0f:\\xb0\\x013\\x00\\x02\\x8a\\xe0n\\xf6\\xd3\\x00\\x1b\\xe0\\x07\\xba\\xd0\\x10\\rQ\\x02\\x13\\xc3\\x0e\\xce\\xf0\\x0b\\x18\\xf0\\x0b}\\xf0\\x08f\\x00\\x02?0\\x01\\xb5\\x10\\x0c\\t\\x80\\x07\\xf0\\x00\\x03\\x85@\\x03\\x07\\x80\\x01\\x1e\\xd04N\\x10\\x11=t\\re0\\x0b?\\x00\\x04\\xf3\\xa1\\x06\\xd8`\\x07\\xd8\\x00\\x03\\xd8\\x95O]\\x80\\x05\\x0fR\\x03\\xd4 \\x05\\x8b\\x80\\x03t\\x83\"\\x15\\x91\\x0bG \\x05N\\xc0\\x02\\xb7@\\x10\\xba\\xe1\\x04- \\x02\\'\\x90\\x000\\x80\\x06*\\x90*7 \\x00X\\xb0\\x0bl\\xf0\\x04\\x9e\\x80\\x06\\xbe r\\x0e\\xb0\\x01x8\\x0b\\xf2\\xff\\xd7C\\x1e\\xb0\\x07e\\x80\\x03\\x19\\xb0\\x03\\x13p\\x05j\\x00\\x0f1\\xc4\\x03P\\x88\\rM\\xf0\\x04O\\xe0\\x0f\\x82p\\x068\\xa0\\x01-\\x00Ho\\x18%\\x1a0\\x00.\\xd7C\\xb1P\\x05> \\n\\xa6\\x90\\x02\\x1ab\\x07M0\\x01X\\x10\\x04\\xcb\\xc0\\tX\\x80\\x05\\x00`\\x00\\xfe\\xd0\\x00\\x1e\\xf0\\x03>\\x10Pd\\xb2\\x0b\\xfe\\x00\\r-\\xa0\\x05\\xc2\\xf0\\x01\\xeb \\x05\\x13\\x90\\x05\\t\\xc5\\x03\\xcaP\\x01\\x13\\x80\"\\xd7\\xf0\\x00\\x1f\\xf0\\x03Z\\x00\\x02\\xf2`\\x85\\xb3\\x17\\x04k0\\x0e\\xb9\\xb0\\x0c\\x041F)\\xa0\\x05p\\x97\\x01$\\xd0\\x01\\xf0\\xc0\\x04\\xcb\\xc0\\x04W0\\x019\\x10\\x04]\\x90\\x05C\\x80\\x0c@\\x10\\x07\\x0bc)<\\xd3\\x10\\xca\\xa8?7@\\x0b%\\xd0\\x01\\xcd@\\x03\\xd4\\x84\\x06\\xed \\x01\\x0f\\x00\\x04\\x1c\\xe0\\x08\\x89\\xb0\\x07\\x8f\\x93\\x11[A\\x11\\xb6\"\\x01n\\x00\\tn \\x0c\\x1e \\x01\\xf7`\\r50\\x01\\x13\\x10\\x08\\xdfp\\x0ft\\xb0\\x08\\x8aP\\x05\\x0c\\x93\\x01\\xe0\\x88;\\x8bP6T\\x86\\x03, \\x00\\x1bp\\x02\\\\0\\x07s\\xbe \\x0f8\\x90T \\xa0\\x05L\\xc537\\xb1\\x0bc\\xa4\\x06r@\\x0f> \\x02N0\\x0cs\\xc0\\x05\\xfd \\x0b@\\xb0\\x08\\x7f\\x10\\x03U\\xc0R\"\\x80\\x0c-\\xf9\\x18\\xe9\\x11\\x0f>\\xd08U\\xe0\\x08q\\x00\\x05N\\x10\\x07\\x86\\xd0<\\xda\\xb0\\x07\\x8a\\xd0\\x05\\x05\\x83\\x1bct\\x04\\x1e\\xa0\\x92\\xfe\\xa2\\x05U\\xb0\\x02+0\\x00\\x84p9\\xda0\\x0bf@X\\x191F\\xd6\\xa7\\x08n\\xc0[ \\xd0\\x02\\x90@\\x0f\\x90\\x00070\\x14\\xfcA\\x1e8q\\x1eGp$\\tq\\x05\\x0f\\x10\\x07e\\x00\\t\\xdb\\xc2-\\xf40\\x0b\\x8e@\\x0b\\xa18-\\x17\\xa12i\\xd0\\r\\xd0\\x00\\r\\x1c\\x10\\x88\\x1dp|\\x899\\x1e\\xa8q\\x1dR\\x93\\x10\\xe5 \\x01\\xab\\xc2\\x00\\x1e@\\x02h\\x99\\x10\\xe68\\x11\\x01\\x01\\x00;'" + ] + }, + { + "Name": "ThumbnailPhotoFileName", + "DataType": "nvarchar", + "Definition": "The ThumbnailPhotoFileName column in the SalesLT.Product entity contains filenames of thumbnail images associated with each product. The filenames typically include a description of the product followed by '_small' and the file extension. This pattern indicates that the files are likely smaller, thumbnail-sized versions of product images, commonly in GIF format. The filenames help in referencing the specific thumbnail image for the corresponding product in the database.", + "AllowedValues": null, + "SampleValues": [ + "superlight_silver_small.gif", + "single_headlight_small.gif", + "water_bottle_cage_small.gif", + "tail_lights_small.gif", + "julianax_r_02_yellow_small.gif" + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The column rowguid in the SalesLT.Product entity contains unique identifier values (GUIDs) in the standard format of a 32-character hexadecimal string, divided into five groups separated by hyphens. Each value in this column is used to uniquely identify rows within the Product entity. The format typically ensures high uniqueness and is commonly used for synchronization or to generate unique keys across different tables or databases.", + "AllowedValues": null, + "SampleValues": [ + "22DF26F2-60BC-493E-A14A-5500633E9F7E", + "47AB0300-7B55-4D35-A786-80190976B9B5", + "AE638923-2B67-4679-B90E-ABBAB17DCA31", + "AAD81532-A572-49A5-83C3-DFA9E3B4FEA6", + "A3EE6897-52FE-42E4-92EC-7A91E7BB905A" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.Product entity contains timestamp values indicating the last date and time a product record was modified. The timestamps are in the format YYYY-MM-DD HH:MM:SS.ssssss. This column helps track changes and updates to product information, ensuring that the most recent modifications are recorded and can be referenced for audit or synchronization purposes.", + "AllowedValues": null, + "SampleValues": [ + "2008-03-11 10:03:55.510000", + "2008-03-11 10:01:36.827000" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductCategory.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductCategory.json index 4462850..64a011f 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductCategory.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductCategory.json @@ -1,67 +1,99 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ProductCategoryID column in the SalesLT.ProductCategory entity contains numeric identifiers for various product categories. The values are unique integers that correspond to specific categories within the product catalog. This column is typically used to link products to their respective categories for organizational and reporting purposes.", - "Name": "ProductCategoryID", - "SampleValues": [ - 36, - 32, - 37, - 22, - 26 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The ParentProductCategoryID column in the SalesLT.ProductCategory entity contains integer values that represent the hierarchical parent category of a product category. These values typically correspond to the unique identifiers of parent categories, indicating the structure and relationship between different product categories within the database. The values are numeric and seem to be used to link to higher-level categories that help in organizing products into a hierarchical taxonomy.", - "Name": "ParentProductCategoryID", - "SampleValues": [ - 4, - 3, - 2, - 1 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The Name column in the SalesLT.ProductCategory entity contains names of various product categories related to cycling and outdoor sports. The values in this column represent different types of product groupings such as equipment, gear, and apparel. Each name provides a general description of the category, helping to classify products in the inventory under identifiable groups.", - "Name": "Name", - "SampleValues": [ - "Mountain Frames", - "Bottles and Cages", - "Shorts", - "Road Bikes", - "Wheels" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.ProductCategory entity contains unique identifier (GUID) values for each product category. These values follow the standard GUID format, which consists of 32 hexadecimal digits arranged in groups separated by hyphens, such as '9B7DFF41-9FA3-4776-8DEF-2C9A48C8B779'. This column is typically used to ensure the uniqueness of each row within the table and can serve as a primary key or for replication purposes. The values are randomly generated and do not follow a sequential order.", - "Name": "rowguid", - "SampleValues": [ - "9B7DFF41-9FA3-4776-8DEF-2C9A48C8B779", - "3EF2C725-7135-4C85-9AE6-AE9A3BDD9283", - "6D24AC07-7A84-4849-864A-865A14125BC9", - "701019C3-09FE-4949-8386-C6CE686474E5", - "CFBDA25C-DF71-47A7-B81B-64EE161AA37C" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.ProductCategory entity contains timestamps indicating when a record was last updated. The values follow the standard date and time format 'YYYY-MM-DD HH:MM:SS'. This column is typically used for tracking the most recent changes or modifications made to a product category record.", - "Name": "ModifiedDate", - "SampleValues": [ - "2002-06-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.ProductCategory entity contains information about different product categories within the sales database. It includes details such as the category ID, parent category ID for hierarchical structuring, category name, unique identifier, and the date the entry was last modified. This entity is useful for answering questions related to product category organization, identifying parent-child category relationships, and tracking the modifications of category details over time.", - "Entity": "SalesLT.ProductCategory", - "EntityName": "Product Category Information" -} + "Entity": "SalesLT.ProductCategory", + "Definition": "The SalesLT.ProductCategory entity contains information about the different categories of products in the sales database. This entity includes details such as the unique identifier for each category, the identifier for parent categories, the name of the category, and metadata like the last modification date. Questions that can be answered using this entity include identifying all product categories, understanding the hierarchical structure of product categories, and tracking when categories were last updated.", + "EntityName": "Product Category Data", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.Product", + "ForeignKeys": [ + { + "Column": "ProductCategoryID", + "ForeignColumn": "ProductCategoryID" + } + ] + }, + { + "ForeignEntity": "SalesLT.ProductCategory", + "ForeignKeys": [ + { + "Column": "ParentProductCategoryID", + "ForeignColumn": "ProductCategoryID" + }, + { + "Column": "ProductCategoryID", + "ForeignColumn": "ParentProductCategoryID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.ProductCategory -> SalesLT.ProductCategory", + "SalesLT.ProductCategory -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.ProductCategory -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.ProductCategory -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ], + "Columns": [ + { + "Name": "ProductCategoryID", + "DataType": "int", + "Definition": "The ProductCategoryID column in the SalesLT.ProductCategory entity contains unique identifiers for different product categories. Each value represents a specific category of products within the database. These identifiers are numeric and typically range from single-digit to multi-digit numbers. The values in this column are used to categorize and differentiate products for organization and retrieval purposes.", + "AllowedValues": null, + "SampleValues": [ + 24, + 36, + 25, + 9, + 10 + ] + }, + { + "Name": "ParentProductCategoryID", + "DataType": "int", + "Definition": "The ParentProductCategoryID column in the SalesLT.ProductCategory entity contains numerical identifiers that represent the parent product category ID for each product category. These values are integers and indicate a hierarchical structure within product categories, where each ID points to another category that serves as its parent in the hierarchy. The column helps to establish and navigate the relationships between broader and more specific product categories.", + "AllowedValues": null, + "SampleValues": [ + 4, + 3, + 2, + 1 + ] + }, + { + "Name": "Name", + "DataType": "nvarchar", + "Definition": "The Name column in the SalesLT.ProductCategory entity contains the names of various product categories. The values are descriptive terms representing different categories of products sold, such as types of accessories, apparel, and bicycle parts. The names are generally concise, composed of one or two words, and provide a quick reference to the type of product group.", + "AllowedValues": null, + "SampleValues": [ + "Locks", + "Jerseys", + "Road Frames", + "Components", + "Wheels" + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.ProductCategory entity contains unique identifier values (GUIDs) for each product category. The values are in the standard 36-character UUID format, which includes alphanumeric characters separated by hyphens. This column is typically used to ensure each product category entry has a globally unique identifier for database operations and synchronization purposes. The GUID format aids in preventing duplication and maintaining data integrity across systems.", + "AllowedValues": null, + "SampleValues": [ + "43B445C8-B820-424E-A1D5-90D81DA0B46F", + "6D24AC07-7A84-4849-864A-865A14125BC9", + "5515F857-075B-4F9A-87B7-43B4997077B3", + "5DEB3E55-9897-4416-B18A-515E970BC2D1", + "A9E54089-8A1E-4CF5-8646-E3801F685934" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.ProductCategory entity contains timestamps indicating the last date and time a product category record was modified. The values in this column are in the datetime format 'YYYY-MM-DD HH:MM:SS' and include both date and time components down to the second. This column is useful for tracking changes and updates to product category records over time.", + "AllowedValues": null, + "SampleValues": [ + "2002-06-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductDescription.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductDescription.json index 061056a..b5c36eb 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductDescription.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductDescription.json @@ -1,56 +1,74 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ProductDescriptionID column in the SalesLT.ProductDescription entity contains unique identifier values for each product description. These values are integers and appear to be sequential or randomly assigned without a specific pattern. This column serves as a primary key to uniquely identify and reference each product description entry in the table.", - "Name": "ProductDescriptionID", - "SampleValues": [ - 1532, - 1606, - 1573, - 1146, - 1766 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The Description column in the SalesLT.ProductDescription entity contains detailed textual descriptions of various bicycle products and their components. These descriptions are multilingual, indicating that products cater to a diverse, international market. The content typically highlights the key features, materials, and uses of the items, such as aerodynamic rims, ergonomic gel seats, and high-performance carbon forks.", - "Name": "Description", - "SampleValues": [ - "Clipless pedals - aluminum.", - "\u0642\u0636\u064a\u0628 \u0642\u064a\u0627\u062f\u0629 \u0645\u0644\u0627\u0626\u0645 \u0644\u0643\u0627\u0641\u0629 \u0627\u0644\u0623\u063a\u0631\u0627\u0636 \u0639\u0644\u0649 \u0627\u0644\u0637\u0631\u0642 \u0627\u0644\u0645\u0645\u0647\u062f\u0629 \u0648\u063a\u064a\u0631 \u0627\u0644\u0645\u0645\u0647\u062f\u0629.", - "Aerodynamic rims for smooth riding.", - "\u05de\u05d5\u05e9\u05d1 \u05d2'\u05dc \u05e0\u05d5\u05d7 \u05d1\u05e2\u05dc \u05e2\u05d9\u05e6\u05d5\u05d1 \u05d0\u05e8\u05d2\u05d5\u05e0\u05d5\u05de\u05d9.", - "Fourche pour route en carbone hautes performances avec bras incurv\u00e9s." - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.ProductDescription entity contains unique identifiers for each product description. The values in this column are in the format of GUIDs (Globally Unique Identifiers), which are 128-bit numbers represented as a series of hexadecimal digits separated by hyphens. Each GUID ensures a unique identity for a record within the table, commonly used to maintain uniqueness in a distributed system or across different databases.", - "Name": "rowguid", - "SampleValues": [ - "B9F94C67-9B0A-42D4-BE78-9401AC9AA833", - "08CEBACE-523F-4FB9-937C-43C8D457520B", - "F8DE509E-C18F-4FE6-8DAC-6F49F1103E32", - "581CC0DC-284C-4370-A2D3-25F2D5382D8C", - "4AAE6D4F-8320-4F32-99DE-BB3B1B13F1EF" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.ProductDescription entity contains timestamp values representing the date and time when a product description was last modified. The values follow the SQL datetime format, typically including both date and time components down to fractions of a second. This column is useful for tracking and filtering records based on their most recent updates.", - "Name": "ModifiedDate", - "SampleValues": [ - "2008-03-11 10:32:17.973000", - "2007-06-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.ProductDescription entity contains data related to the descriptions of products, including unique identifiers and timestamps for modifications. This entity is essential for understanding the textual details associated with different products. It can be used to answer questions about the specific descriptions of products, when these descriptions were last modified, and to track changes through globally unique identifiers.", - "Entity": "SalesLT.ProductDescription", - "EntityName": "Product Descriptions" -} + "Entity": "SalesLT.ProductDescription", + "Definition": "The SalesLT.ProductDescription entity contains details about product descriptions used in a sales database. It uniquely identifies each product description with a ProductDescriptionID, stores the actual description text, and includes metadata such as a unique rowguid and the date the record was last modified. This entity can be used to answer questions related to the specific descriptions of products, track historical changes to product descriptions, or generate reports that include detailed product information for sales and marketing purposes.", + "EntityName": "Product Descriptions", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.ProductModelProductDescription", + "ForeignKeys": [ + { + "Column": "ProductDescriptionID", + "ForeignColumn": "ProductDescriptionID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.ProductDescription -> SalesLT.ProductModelProductDescription -> SalesLT.ProductModel -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.ProductDescription -> SalesLT.ProductModelProductDescription -> SalesLT.ProductModel -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.ProductDescription -> SalesLT.ProductModelProductDescription -> SalesLT.ProductModel -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ], + "Columns": [ + { + "Name": "ProductDescriptionID", + "DataType": "int", + "Definition": "The ProductDescriptionID column in the SalesLT.ProductDescription entity contains unique numeric identifiers for each product description. Each value in this column is an integer that serves as a primary key to distinguish one product description from another. The values do not follow a specific format other than being positive integers and are used to reference specific product descriptions within the database.", + "AllowedValues": null, + "SampleValues": [ + 1569, + 1832, + 1763, + 1707, + 2003 + ] + }, + { + "Name": "Description", + "DataType": "nvarchar", + "Definition": "The Description column in the SalesLT.ProductDescription entity contains detailed product descriptions in various languages. These descriptions provide specific information about the product\u2019s features and benefits, such as durability, functionality, and design. The descriptions appear to cater to a global market, offering text in languages like Chinese, Arabic, Thai, English, and French. This diversity indicates that the column is used to store localized product descriptions for different regions or customer bases.", + "AllowedValues": null, + "SampleValues": [ + "\u94a2\u4e1d\u6491\u8f6e\u5708\u5916\u80ce\u7684\u4ef7\u683c\u4fbf\u5b9c\uff0c\u8f6e\u80ce\u9762\u5374\u4e0e\u4ef7\u683c\u66f4\u8d35\u7684\u8f6e\u80ce\u540c\u6837\u51fa\u8272\u3002", + "\u0644\u0639\u0627\u0634\u0642\u064a \u0642\u064a\u0627\u062f\u0629 \u0627\u0644\u062f\u0631\u0627\u062c\u0627\u062a \u0641\u064a \u0627\u0644\u0645\u0645\u0631\u0627\u062a \u063a\u064a\u0631 \u0627\u0644\u0645\u0645\u0647\u062f\u0629. \u062f\u0631\u0627\u062c\u0629 \u0634\u062f\u064a\u062f\u0629 \u0627\u0644\u062a\u062d\u0645\u0644 \u064a\u0645\u0643\u0646\u0643 \u0627\u0644\u0627\u0646\u0637\u0644\u0627\u0642 \u0628\u0647\u0627 \u0625\u0644\u0649 \u0623\u064a \u0645\u0643\u0627\u0646 \u0628\u0645\u0627 \u062a\u0648\u0641\u0631\u0647 \u0644\u0643 \u0645\u0646 \u062a\u062d\u0643\u0645 \u0639\u0644\u0649 \u0627\u0644\u0637\u0631\u0642 \u0627\u0644\u0648\u0639\u0631\u0629\u060c \u0643\u0644 \u0647\u0630\u0627 \u062f\u0648\u0646 \u0623\u0646 \u062a\u062a\u062c\u0627\u0648\u0632 \u0645\u064a\u0632\u0627\u0646\u064a\u062a\u0643.", + "\u0e01\u0e32\u0e23\u0e2d\u0e2d\u0e01\u0e41\u0e1a\u0e1a\u0e17\u0e35\u0e48\u0e21\u0e31\u0e48\u0e19\u0e04\u0e07 \u0e23\u0e31\u0e1a\u0e41\u0e23\u0e07\u0e01\u0e23\u0e30\u0e41\u0e17\u0e01\u0e41\u0e25\u0e30\u0e43\u0e2b\u0e49\u0e01\u0e32\u0e23\u0e04\u0e27\u0e1a\u0e04\u0e38\u0e21\u0e17\u0e35\u0e48\u0e41\u0e21\u0e48\u0e19\u0e22\u0e33", + "Triple crankset; alumunim crank arm; flawless shifting.", + "Un v\u00e9ritable v\u00e9lo multi-sports, qui offre une conduite optimis\u00e9e et une ligne r\u00e9volutionnaire. Sa ligne a\u00e9rodynamique vous permet de l'utiliser en course et ses vitesses de gravir les cols." + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.ProductDescription entity contains unique identifier values for each product description. These values are in the form of GUIDs (Globally Unique Identifiers), ensuring that each entry is distinct and can be reliably used to identify and reference specific product descriptions within the database. The pattern of the sample values indicates they are in the standard 36-character GUID format, including hyphens separating sections of hexadecimal digits.", + "AllowedValues": null, + "SampleValues": [ + "A400C418-2DEF-490D-98BB-BDF8B7D47853", + "4F5E9527-565D-462E-88C0-6453FE86EA7A", + "853B8535-E4A6-4C17-B2AC-9E05DA2D6ECD", + "E11A3C2A-B074-48F9-8226-16D65C2F91C2", + "07ADF9DE-A65D-46D3-9FE3-4F7D49691066" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.ProductDescription entity contains the date and time when the product description record was last updated. The values are in the format of YYYY-MM-DD HH:MM:SS.nnnnnn, which includes the date followed by the time down to microseconds. This column helps track changes and updates to the product description records over time.", + "AllowedValues": null, + "SampleValues": [ + "2008-03-11 10:32:17.973000", + "2007-06-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModel.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModel.json index 7920b59..724116b 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModel.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModel.json @@ -1,66 +1,94 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ProductModelID column in the SalesLT.ProductModel entity contains unique identifiers for different product models. Each value in this column is a distinct integer that serves as the primary key for the product model records in the database. These identifiers are used to link product models to other related data within the database.", - "Name": "ProductModelID", - "SampleValues": [ - 72, - 73, - 24, - 116, - 6 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The Name column in the SalesLT.ProductModel entity contains product names typically composed of a brand abbreviation followed by a descriptive term and, occasionally, a numerical differentiator. The names often describe the type and specific model of various bicycle components or related products. This structured naming convention aids in easy identification and categorization of the products within the inventory.", - "Name": "Name", - "SampleValues": [ - "Touring Pedal", - "HL Road Seat/Saddle 2", - "HL Mountain Frame", - "ML Mountain Front Wheel", - "LL Mountain Handlebars" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The CatalogDescription column in the SalesLT.ProductModel entity contains text descriptions of product models as they are showcased in the product catalog. This column typically includes detailed information about the product features, specifications, and other relevant details that help customers understand the product better. The data in this column is often used for creating product listings and marketing materials.", - "Name": "CatalogDescription", - "SampleValues": null, - "Type": "xml" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.ProductModel entity contains unique identifier values in the standard GUID (Globally Unique Identifier) format. Each value is a 128-bit integer used to distinctly identify records within the table. These GUIDs ensure that each entry can be uniquely referenced, which is particularly useful in distributed systems and for maintaining data integrity.", - "Name": "rowguid", - "SampleValues": [ - "E7B00DFF-8136-4947-B503-994584CC89E7", - "5CEFBB6E-3B7E-414F-AC1B-8F6DF741FB21", - "45FE0D77-6645-473C-A116-1232BAEA8D43", - "C88D1136-A8BB-46BB-94AA-8C1854F813CC", - "0D3A6AD7-6891-4DE9-B14F-E1A841EB220C" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.ProductModel entity contains timestamps indicating when each product model was last modified. The entries are represented in the standard timestamp format of 'YYYY-MM-DD HH:MM:SS.FFFFFF', capturing both date and time at a high precision level. This information is essential for tracking changes and maintaining historical accuracy of modifications within the product models.", - "Name": "ModifiedDate", - "SampleValues": [ - "2009-05-16 16:34:29.027000", - "2006-11-20 09:56:38.273000", - "2009-05-16 16:34:28.997000", - "2009-05-16 16:34:29.010000", - "2005-06-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.ProductModel entity contains information about different product models within the organization. It includes details such as the unique identifier for each product model, the name of the model, and a description used in the product catalog. Additionally, it tracks the last modification date and a globally unique identifier (GUID) for each record. This entity can be used to answer questions related to identifying, describing, and managing product models, as well as tracking changes made to the product models over time.", - "Entity": "SalesLT.ProductModel", - "EntityName": "Product Model Information" -} + "Entity": "SalesLT.ProductModel", + "Definition": "The SalesLT.ProductModel entity contains information about different product models within a company's product catalog. It includes details such as the unique identifier for each product model, the name of the product model, and a description of the product model as listed in the catalog. This entity also includes a globally unique identifier and the date the record was last modified. Questions that can be answered using this entity include identifying product model names, retrieving specific product model descriptions, and tracking the last modification dates of product models.", + "EntityName": "Product Model Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.Product", + "ForeignKeys": [ + { + "Column": "ProductModelID", + "ForeignColumn": "ProductModelID" + } + ] + }, + { + "ForeignEntity": "SalesLT.ProductModelProductDescription", + "ForeignKeys": [ + { + "Column": "ProductModelID", + "ForeignColumn": "ProductModelID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.ProductModel -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.ProductModel -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.ProductModel -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address", + "SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription" + ], + "Columns": [ + { + "Name": "ProductModelID", + "DataType": "int", + "Definition": "The ProductModelID column in the SalesLT.ProductModel entity contains unique identifier numbers for different product models. These values are integers and are used to distinguish and reference various product models within the database. Each product model has a distinct ProductModelID which is used in various queries and joins to uniquely identify the model.", + "AllowedValues": null, + "SampleValues": [ + 13, + 57, + 95, + 20, + 117 + ] + }, + { + "Name": "Name", + "DataType": "nvarchar", + "Definition": "The Name column in the SalesLT.ProductModel entity contains names of product models. These names typically include descriptive terms related to the product type and often feature a combination of words and numbers. The values may include elements such as the product category, model specifications, or unique identifiers. The format of the names varies, ranging from simple descriptive names to more specific and detailed descriptions.", + "AllowedValues": null, + "SampleValues": [ + "Touring Tire", + "Sport-100", + "Road-750", + "LL Mountain Seat/Saddle 1", + "All-Purpose Bike Stand" + ] + }, + { + "Name": "CatalogDescription", + "DataType": "xml", + "Definition": "The CatalogDescription column in the SalesLT.ProductModel entity contains textual data that provides a detailed description of the product models available in the catalog. This includes information such as features, specifications, and usage details, which helps customers understand the product better. The data in this column is typically lengthy and formatted in XML or JSON to support rich text descriptions. This column is useful for generating product literature and online catalog pages.", + "AllowedValues": null, + "SampleValues": null + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.ProductModel entity contains unique identifier values in the form of GUIDs (Globally Unique Identifiers). These GUIDs are used to ensure that each record in the ProductModel table can be uniquely identified across different tables, databases, and servers, providing a reliable way to distinguish each product model entry. The values follow the standard GUID format, consisting of 32 hexadecimal characters separated by hyphens into five groups.", + "AllowedValues": null, + "SampleValues": [ + "D71BD21C-239E-4C2B-98A3-101962D6B2D3", + "3CDF61D6-6209-436F-B235-82E8F159208B", + "3494E8FF-7DAF-4860-ABF6-97842048E272", + "E7B00DFF-8136-4947-B503-994584CC89E7", + "0434F63A-A361-4D0B-A9FC-8AC2A866CE85" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.ProductModel entity contains timestamp values indicating the date and time when each product model record was last modified. The values follow the standard SQL datetime format, including both date and time components, down to fractions of a second. This column is likely used to track changes and updates to product model records for auditing purposes.", + "AllowedValues": null, + "SampleValues": [ + "2009-05-16 16:34:29.010000", + "2005-06-01 00:00:00", + "2002-05-02 00:00:00", + "2009-05-16 16:34:29.027000", + "2009-05-16 16:34:29.043000" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModelProductDescription.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModelProductDescription.json index 64c1135..36914b3 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModelProductDescription.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.ProductModelProductDescription.json @@ -1,68 +1,96 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ProductModelID column in the SalesLT.ProductModelProductDescription entity contains unique numerical identifiers for different product models. These values are integers and are used to link product descriptions to their corresponding product models within the database. The IDs do not follow a specific sequential order and are likely assigned based on a predefined schema or during the creation of product models.", - "Name": "ProductModelID", - "SampleValues": [ - 103, - 110, - 39, - 85, - 37 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The ProductDescriptionID column in the SalesLT.ProductModelProductDescription entity contains unique numerical identifiers assigned to each product description. The values appear to be integers typically starting from a specific range and are used to reference detailed descriptions of products within the database. Each ID uniquely identifies an entry in the product description table to ensure consistency and accuracy in product-related information.", - "Name": "ProductDescriptionID", - "SampleValues": [ - 1900, - 1634, - 1519, - 1438, - 1964 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The Culture column in the SalesLT.ProductModelProductDescription entity contains language and region codes commonly used for localization and internationalization purposes. The values appear to follow ISO 639-1 language codes and may include an additional region or script designation using a hyphen. These codes help identify the language or cultural context for product descriptions, enhancing the ability to cater to diverse markets.", - "Name": "Culture", - "SampleValues": [ - "fr ", - "en ", - "th ", - "ar ", - "zh-cht" - ], - "Type": "nchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.ProductModelProductDescription entity contains unique identifier values for each row. These values follow the standard UUID (Universal Unique Identifier) format which consists of 32 alphanumeric characters separated into five groups by hyphens, typically in the format 8-4-4-4-12. This ensures that each entry in the column is globally unique, providing a reliable way to distinguish individual records in the database.", - "Name": "rowguid", - "SampleValues": [ - "52D0E73D-BFBF-4CD8-A8B8-52FC0AF423D8", - "AB93B739-E95E-4C4A-A570-B93349EA678C", - "AAB952AE-55D8-4D0F-B63A-1250B7666AE8", - "26966676-DD7B-4CE9-8DE7-79F97B8A5DC9", - "4AA960B3-4CC8-4F01-BB82-989ADBD4D036" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.ProductModelProductDescription entity contains timestamp values indicating the date and time when each record was last modified. The values follow a standard datetime format, typically including both the date and the exact time of modification down to seconds. This column is useful for tracking changes and updates to the records over time.", - "Name": "ModifiedDate", - "SampleValues": [ - "2007-06-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.ProductModelProductDescription entity links product models to their descriptions, capturing details about the culture/language of the description. It includes metadata such as a unique identifier and the date of the last modification. This entity can be used to answer questions regarding the specific descriptions available for different product models, including which languages those descriptions are provided in.", - "Entity": "SalesLT.ProductModelProductDescription", - "EntityName": "'Product Model and Description Mapping'" -} + "Entity": "SalesLT.ProductModelProductDescription", + "Definition": "The SalesLT.ProductModelProductDescription entity links product models to their descriptions across different cultures. It holds data about the association between a product model and its corresponding description, including which language or culture the description pertains to. This entity is useful for answering questions related to the multilingual descriptions of product models, tracking modifications, and ensuring cultural relevance in product information.", + "EntityName": "Product Model and Description Association", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.ProductDescription", + "ForeignKeys": [ + { + "Column": "ProductDescriptionID", + "ForeignColumn": "ProductDescriptionID" + } + ] + }, + { + "ForeignEntity": "SalesLT.ProductModel", + "ForeignKeys": [ + { + "Column": "ProductModelID", + "ForeignColumn": "ProductModelID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.ProductModelProductDescription -> SalesLT.ProductModel -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.ProductModelProductDescription -> SalesLT.ProductModel -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.ProductModelProductDescription -> SalesLT.ProductModel -> SalesLT.Product -> SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ], + "Columns": [ + { + "Name": "ProductModelID", + "DataType": "int", + "Definition": "The ProductModelID column in the SalesLT.ProductModelProductDescription entity contains numeric identifiers that correspond to specific product models. Each unique ProductModelID represents a distinct product model and is used to link product descriptions to their respective models. The values are integers, and they appear to be sequential, serving as foreign keys to other related tables that provide additional details about the product models.", + "AllowedValues": null, + "SampleValues": [ + 1, + 91, + 47, + 3, + 40 + ] + }, + { + "Name": "ProductDescriptionID", + "DataType": "int", + "Definition": "The ProductDescriptionID column in the SalesLT.ProductModelProductDescription entity contains unique numeric identifiers for product descriptions. These identifiers are used to link specific product models to their respective descriptions in the database. The values are integers with no apparent pattern, indicating each product description's distinct entry in the system.", + "AllowedValues": null, + "SampleValues": [ + 1799, + 1862, + 1905, + 1825, + 1426 + ] + }, + { + "Name": "Culture", + "DataType": "nchar", + "Definition": "The Culture column in the SalesLT.ProductModelProductDescription entity contains codes representing different cultures or languages. The values follow an abbreviation format, where some are two-letter language codes (e.g., 'he' for Hebrew, 'fr' for French, 'th' for Thai) and others follow a language-region format (e.g., 'zh-cht' for Traditional Chinese). These codes are used to indicate the language in which the product description is provided.", + "AllowedValues": null, + "SampleValues": [ + "he ", + "fr ", + "zh-cht", + "th ", + "ar " + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The column rowguid in the SalesLT.ProductModelProductDescription entity contains globally unique identifier (GUID) values in the standard 36-character format. These values are used to uniquely identify each record in the table and ensure that each record can be distinctly referenced. The GUIDs are generated in a standard format that includes hexadecimal characters separated by hyphens. This column helps maintain the uniqueness of records across the database and may be used for tasks that require unique entity identification.", + "AllowedValues": null, + "SampleValues": [ + "C07515EF-9092-4BDD-BA2A-A49AB7FD98D3", + "284B8A07-645B-48EB-B4C0-F8EAE2A44DDB", + "C00AB8B7-1451-4A28-AF77-621A2D6F0674", + "77117A9F-3529-4E90-965A-17F306A5A6C7", + "40B7B7EF-0816-4BD2-A9A8-D7533D635D16" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.ProductModelProductDescription entity contains the date and time when the corresponding record was last updated. The values are in the format 'YYYY-MM-DD HH:MM:SS' which includes both the date and the precise time of modification. This provides a time-stamp for tracking changes to the records and ensuring data is current as of the last update.", + "AllowedValues": null, + "SampleValues": [ + "2007-06-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderDetail.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderDetail.json index bdf10ff..37d7cdf 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderDetail.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderDetail.json @@ -1,120 +1,148 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The SalesOrderID column in the SalesLT.SalesOrderDetail entity contains unique numerical identifiers assigned to individual sales orders. These identifiers are used to associate specific sales order details with their corresponding sales orders. The values in this column are distinct integers, ensuring each sales order can be uniquely identified for tracking and referencing purposes.", - "Name": "SalesOrderID", - "SampleValues": [ - 71846, - 71796, - 71920, - 71936, - 71885 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The SalesOrderDetailID column in the SalesLT.SalesOrderDetail entity contains unique numeric identifiers for each sales order detail. Each value in this column is a sequentially assigned integer, ensuring that each sales order detail can be distinctly identified. This column is likely set as the primary key for the SalesOrderDetail table.", - "Name": "SalesOrderDetailID", - "SampleValues": [ - 110787, - 110734, - 112142, - 112931, - 110751 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The OrderQty column in the SalesLT.SalesOrderDetail entity contains numerical values representing the quantity of items ordered in a sales transaction. The values are whole numbers indicating individual item counts per order line. This column helps in identifying the volume of products associated with each sales order detail. The range of values can vary depending on the nature of the order.", - "Name": "OrderQty", - "SampleValues": [ - 5, - 25, - 4, - 9, - 10 - ], - "Type": "smallint" - }, - { - "AllowedValues": null, - "Definition": "The ProductID column in the SalesLT.SalesOrderDetail entity contains numerical identifiers for products associated with each sales order detail. The values are integers and are used to uniquely identify each product within the system. This column helps in linking sales order details to specific products in the product catalog.", - "Name": "ProductID", - "SampleValues": [ - 884, - 712, - 874, - 975, - 889 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The UnitPrice column in the SalesLT.SalesOrderDetail entity contains numerical values representing the price per unit of items in a sales order. The values are expressed in a decimal format with four digits of precision. This column is used to denote the cost assigned to each unit of a product in the sales transactions.", - "Name": "UnitPrice", - "SampleValues": [ - "2.9940", - "818.7000", - "202.3320", - "16.2720", - "1391.9940" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The UnitPriceDiscount column in the SalesLT.SalesOrderDetail entity contains the discount rates applied to the unit prices of items in a sales order. The values are decimal numbers representing the discount percentage with a precision of four decimal places. Common values include 0.4000 for a 40% discount, 0.1000 for a 10% discount, and 0.0000 for no discount.", - "Name": "UnitPriceDiscount", - "SampleValues": [ - "0.4000", - "0.1000", - "0.0500", - "0.0200", - "0.0000" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The LineTotal column in the SalesLT.SalesOrderDetail entity contains the total monetary amount for each sales order detail line. The values are formatted as decimal numbers with up to six decimal places, indicating the precision of the total amounts. This column likely represents the final cost after applying any discounts and taxes to the individual items on the order.", - "Name": "LineTotal", - "SampleValues": [ - "16.272000", - "8796.060000", - "4398.030000", - "517.170108", - "3117.870000" - ], - "Type": "numeric" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.SalesOrderDetail entity contains unique identifier values for each row, formatted as globally unique identifiers (GUIDs). These GUIDs ensure that each record can be distinctly identified, even across different systems. The values follow the standard GUID format, consisting of 32 hexadecimal digits, displayed in five groups separated by hyphens: 8-4-4-4-12.", - "Name": "rowguid", - "SampleValues": [ - "F2064E41-044A-4A42-9342-FB45BE83EB88", - "67EB5E24-9231-4656-B19D-27998D6D707D", - "2000D44E-0E7C-4FBA-96D9-55D18727DB36", - "E447CABB-A2CD-4BB0-9927-A6285927BAEC", - "05A28311-9869-486B-BA7B-539517A25F97" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.SalesOrderDetail entity contains timestamp values indicating the date and time when a sales order detail record was last modified. The timestamps follow the 'YYYY-MM-DD HH:MM:SS' format, which is consistent with standard SQL datetime formats. This column is used for tracking changes and updates to the records, providing a historical log for when modifications occurred.", - "Name": "ModifiedDate", - "SampleValues": [ - "2008-06-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.SalesOrderDetail entity contains detailed information about individual items in sales orders. It tracks the quantity, product identifier, unit price, any unit price discounts, and the total line amount for each item within a sales order. This entity is essential for understanding the composition and financial details of sales transactions. Questions that can be answered using this entity include the specifics of what products were ordered, how much each product cost, and the discount applied to each product in a given sales order.", - "Entity": "SalesLT.SalesOrderDetail", - "EntityName": "Sales Order Details" -} + "Entity": "SalesLT.SalesOrderDetail", + "Definition": "The SalesLT.SalesOrderDetail entity contains detailed information about individual items within sales orders. This entity includes data on the sales order ID, the specific details of each order item such as quantity, product ID, unit price, and any discounts applied. It also includes calculated fields such as the line total for each order item. This entity can be used to answer questions related to the specifics of sales transactions, such as which products were purchased in each order, the quantity of each product ordered, and the total price of each order item.", + "EntityName": "Sales Line Items Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.Product", + "ForeignKeys": [ + { + "Column": "ProductID", + "ForeignColumn": "ProductID" + } + ] + }, + { + "ForeignEntity": "SalesLT.SalesOrderHeader", + "ForeignKeys": [ + { + "Column": "SalesOrderID", + "ForeignColumn": "SalesOrderID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ], + "Columns": [ + { + "Name": "SalesOrderID", + "DataType": "int", + "Definition": "The SalesOrderID column in the SalesLT.SalesOrderDetail entity contains unique numerical identifiers for each sales order. Each value represents a specific sales order, ensuring that each order can be individually referenced and tracked. The values are in a sequential numeric format, indicating the progression and uniqueness of each sales transaction within the database.", + "AllowedValues": null, + "SampleValues": [ + 71938, + 71784, + 71935, + 71923, + 71946 + ] + }, + { + "Name": "SalesOrderDetailID", + "DataType": "int", + "Definition": "The SalesOrderDetailID column in the SalesLT.SalesOrderDetail entity contains unique identifier values for each sales order detail record. The values are numeric and are used to distinguish each order detail entry within the database. These identifiers are essential for maintaining data integrity and enabling efficient querying and data manipulation within the sales order system.", + "AllowedValues": null, + "SampleValues": [ + 110735, + 113231, + 110686, + 113257, + 113307 + ] + }, + { + "Name": "OrderQty", + "DataType": "smallint", + "Definition": "The OrderQty column in the SalesLT.SalesOrderDetail entity contains the quantity of items ordered for each sales order detail. This column represents integer values indicating how many units of a product were included in a specific order. The values are numeric and can vary, showing the specific amount ordered for each line item within a sales order.", + "AllowedValues": null, + "SampleValues": [ + 11, + 9, + 16, + 23, + 1 + ] + }, + { + "Name": "ProductID", + "DataType": "int", + "Definition": "The ProductID column in the SalesLT.SalesOrderDetail entity contains numerical identifiers for products. Each value in this column represents a unique product associated with a sales order detail, used to link sales order records to specific products within the inventory. The identifiers are likely integer numbers and may not follow any specific sequential order.", + "AllowedValues": null, + "SampleValues": [ + 884, + 961, + 926, + 944, + 896 + ] + }, + { + "Name": "UnitPrice", + "DataType": "money", + "Definition": "The UnitPrice column in the SalesLT.SalesOrderDetail entity contains the unit prices of products sold in individual sales transactions. The values are represented as decimal numbers, likely indicating the price per unit of a product in a given currency. The prices can vary widely depending on the product and its specifications. The decimal format suggests precision is important for these financial values.", + "AllowedValues": null, + "SampleValues": [ + "2.9940", + "72.0000", + "31.5840", + "31.3142", + "40.5942" + ] + }, + { + "Name": "UnitPriceDiscount", + "DataType": "money", + "Definition": "The UnitPriceDiscount column in the SalesLT.SalesOrderDetail entity contains numerical values representing the discount applied to the unit price of a product. The values are in decimal format where each value indicates the proportion of the discount relative to the unit price. For instance, a value of 0.4000 indicates a 40% discount, while a value of 0.0000 indicates no discount.", + "AllowedValues": null, + "SampleValues": [ + "0.4000", + "0.1000", + "0.0500", + "0.0200", + "0.0000" + ] + }, + { + "Name": "LineTotal", + "DataType": "numeric", + "Definition": "The LineTotal column in the SalesLT.SalesOrderDetail entity contains the total price for each sales order line item. The values represent the monetary amount calculated by multiplying the unit price by the quantity ordered, potentially including any discounts applied. The values are represented as decimal numbers, which can vary greatly depending on the quantity and price of the items ordered. This column is important for financial and sales reporting within the database.", + "AllowedValues": null, + "SampleValues": [ + "23.952000", + "923.388000", + "218.682000", + "13769.940000", + "269.946000" + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.SalesOrderDetail entity contains unique identifier values for each sales order detail entry. These values are in the form of GUIDs (Globally Unique Identifiers) which are 128-bit numbers typically represented in hexadecimal and are used to uniquely identify records. This ensures that each entry in the SalesOrderDetail table can be uniquely referenced across any system. The values follow a standard GUID format, e.g., 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'.", + "AllowedValues": null, + "SampleValues": [ + "281D1C72-EC9A-4E76-93B8-F83217A26A2E", + "BFBD21A7-253A-411A-9FE7-56884370529E", + "686999FB-42E6-4D00-9A14-83FFA86833E3", + "61EFC1C5-71CE-4537-9EDE-723DD776A042", + "FDEDAB25-D27E-4D66-BB57-6A699846C3E9" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.SalesOrderDetail entity contains timestamp values indicating when each record was last updated. The values are in the 'YYYY-MM-DD HH:MI:SS' format. This column helps in tracking the modification history of sales order details. It is essential for auditing and maintaining data integrity by recording the precise date and time of the latest changes.", + "AllowedValues": null, + "SampleValues": [ + "2008-06-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderHeader.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderHeader.json index 5728ae6..9ae9a28 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderHeader.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.SalesOrderHeader.json @@ -1,249 +1,290 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The SalesOrderID column in the SalesLT.SalesOrderHeader entity contains unique identifiers for each sales order. The values are numerical and appear to be sequential, indicating the potential chronological creation of sales orders. Each SalesOrderID is a unique integer used to distinguish individual sales transactions within the database.", - "Name": "SalesOrderID", - "SampleValues": [ - 71895, - 71784, - 71936, - 71796, - 71776 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The RevisionNumber column in the SalesLT.SalesOrderHeader entity contains integer values that represent the number of revisions made to a sales order. Each time a sales order is modified, the revision number is incremented by one. This column is used to track changes and updates to sales orders over time. The values are typically low integers starting from 0.", - "Name": "RevisionNumber", - "SampleValues": [ - 2 - ], - "Type": "tinyint" - }, - { - "AllowedValues": null, - "Definition": "The OrderDate column in the SalesLT.SalesOrderHeader entity contains date and time values representing the exact date and time when a sales order was placed. The values follow the standard datetime format. This column is essential for tracking the order history and processing times, and it may be used for filtering data based on specific periods or timestamps.", - "Name": "OrderDate", - "SampleValues": [ - "2008-06-01 00:00:00" - ], - "Type": "datetime" - }, - { - "AllowedValues": null, - "Definition": "The DueDate column in the SalesLT.SalesOrderHeader entity contains timestamps indicating the due dates for sales orders. The values are formatted as datetime strings, including the date and time, typically set to midnight (00:00:00). The dates are provided in the standard 'YYYY-MM-DD HH:MI:SS' format and are used to indicate when the sales orders are expected to be fulfilled or completed.", - "Name": "DueDate", - "SampleValues": [ - "2008-06-13 00:00:00" - ], - "Type": "datetime" - }, - { - "AllowedValues": null, - "Definition": "The ShipDate column in the SalesLT.SalesOrderHeader entity contains the date and time when each sales order was shipped. The values in this column follow the standard datetime format of 'yyyy-MM-dd HH:mm:ss'. This column is essential for tracking the shipping schedule and delivery logistics of sales orders.", - "Name": "ShipDate", - "SampleValues": [ - "2008-06-08 00:00:00" - ], - "Type": "datetime" - }, - { - "AllowedValues": null, - "Definition": "The Status column in the SalesLT.SalesOrderHeader entity contains numerical codes representing the current status of a sales order. Each numerical value corresponds to a specific status within the sales order process. For instance, a status of 5 indicates a particular state of the order, which could be defined by the business rules governing the sales process.", - "Name": "Status", - "SampleValues": [ - 5 - ], - "Type": "tinyint" - }, - { - "AllowedValues": null, - "Definition": "The OnlineOrderFlag column in the SalesLT.SalesOrderHeader entity indicates whether an order was placed online. It contains Boolean values, with 'True' representing online orders and 'False' representing orders placed through other channels. This column helps identify the source of the sales order.", - "Name": "OnlineOrderFlag", - "SampleValues": [ - false - ], - "Type": "bit" - }, - { - "AllowedValues": null, - "Definition": "The SalesOrderNumber column in the SalesLT.SalesOrderHeader entity contains unique identifiers for sales orders. Each sales order number follows a consistent pattern, typically starting with the prefix 'SO' followed by a series of digits. This column is used to uniquely identify and track individual sales orders within the database.", - "Name": "SalesOrderNumber", - "SampleValues": [ - "SO71946", - "SO71902", - "SO71796", - "SO71938", - "SO71782" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The PurchaseOrderNumber column in the SalesLT.SalesOrderHeader entity contains unique purchase order numbers used to track individual sales orders. The values follow a specific format, starting with the prefix 'PO' followed by a varying series of digits. This format suggests that each purchase order number is a unique alphanumeric identifier used for sales transactions within the system.", - "Name": "PurchaseOrderNumber", - "SampleValues": [ - "PO13021155785", - "PO6119130779", - "PO4002189853", - "PO348186287", - "PO16153112278" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The AccountNumber column in the SalesLT.SalesOrderHeader entity contains alphanumeric values formatted with a pattern of numerical segments separated by hyphens. The values appear to follow a consistent format which includes three groups of digits, suggesting a structured coding system. This format likely represents specific account information used to uniquely identify sales orders within the system.", - "Name": "AccountNumber", - "SampleValues": [ - "10-4020-000016", - "10-4020-000649", - "10-4020-000466", - "10-4020-000106", - "10-4020-000223" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The CustomerID column in the SalesLT.SalesOrderHeader entity contains unique numeric identifiers assigned to each customer. These identifiers are used to link sales orders to the respective customers who placed them. The values are integers, typically in a sequential or near-sequential range, indicating the customer database's internal indexing mechanism.", - "Name": "CustomerID", - "SampleValues": [ - 30019, - 29638, - 30113, - 29922, - 29660 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The ShipToAddressID column in the SalesLT.SalesOrderHeader entity contains numeric identifiers that reference specific shipping addresses for sales orders. Each value in the column is a unique identifier that relates to an address in another table, likely a customer or company address database. The values are integers and do not follow a discernible sequential pattern, indicating they are likely auto-generated keys.", - "Name": "ShipToAddressID", - "SampleValues": [ - 1038, - 653, - 669, - 1090, - 659 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The BillToAddressID column in the SalesLT.SalesOrderHeader entity contains unique integer identifiers that reference the specific addresses where the billing statements are sent. Each ID corresponds to a distinct address in a separate table, usually an address or customer-related table. The values are numerical and do not follow a visible sequence, indicating likely primary key values used for joining tables in database queries.", - "Name": "BillToAddressID", - "SampleValues": [ - 999, - 653, - 992, - 989, - 651 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The ShipMethod column in the SalesLT.SalesOrderHeader entity contains the names of the shipping methods used for sales orders. The values represent different types of shipping methods, which may include specific transport services or carriers. Entries in this column are descriptive names of shipping options, typically indicating the mode or speed of transport.", - "Name": "ShipMethod", - "SampleValues": [ - "CARGO TRANSPORT 5" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The CreditCardApprovalCode column in the SalesLT.SalesOrderHeader entity contains alphanumeric codes used to approve credit card transactions for sales orders. Each code represents the authorization given by the credit card issuer for the transaction. This code is important for financial tracking and validation of payments, ensuring that the sales order has completed the credit card payment process successfully.", - "Name": "CreditCardApprovalCode", - "SampleValues": [], - "Type": "varchar" - }, - { - "AllowedValues": null, - "Definition": "The SubTotal column in the SalesLT.SalesOrderHeader entity contains numeric values representing the subtotal amount for each sales order. The values are in decimal format and include various amounts, likely reflecting the total cost of items before taxes and discounts are applied. This column is essential for calculating the overall financial metrics of sales transactions.", - "Name": "SubTotal", - "SampleValues": [ - "13823.7083", - "40.9045", - "88812.8625", - "2415.6727", - "602.1946" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The TaxAmt column in the SalesLT.SalesOrderHeader entity contains the total tax amount for each sales order. The values are represented as decimal numbers with up to four decimal places, reflecting the precision in calculating the tax for various orders. The amounts can range from relatively small to quite large, indicating variability in the total value of the sales orders taxed.", - "Name": "TaxAmt", - "SampleValues": [ - "6242.3752", - "84.7448", - "7862.2953", - "4610.7707", - "161.3073" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The Freight column in the SalesLT.SalesOrderHeader entity contains numerical values representing the cost of shipping associated with each sales order. Values are expressed in currency and likely represent monetary amounts in a specific unit, such as dollars. Each value is a precise decimal number, reflecting the variability in shipping costs based on factors like order size and shipping method.", - "Name": "Freight", - "SampleValues": [ - "22.0087", - "345.5927", - "1.9703", - "84.9541", - "26.4828" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The TotalDue column in the SalesLT.SalesOrderHeader entity contains the total monetary amount due for each sales order. These values are represented as decimal numbers with four decimal places, indicating the precision required for financial calculations. The data typically reflects varying sizes of customer orders, which can range from smaller transactions to high-value purchases.", - "Name": "TotalDue", - "SampleValues": [ - "92663.5609", - "1261.4440", - "81834.9826", - "3293.7761", - "3673.3249" - ], - "Type": "money" - }, - { - "AllowedValues": null, - "Definition": "The Comment column in the SalesLT.SalesOrderHeader entity contains textual notes or remarks added by users regarding specific sales orders. These comments may include special instructions, observations, or any additional information that is relevant to the processing or delivery of the sales order. This column can contain null values if no comments were made for certain orders.", - "Name": "Comment", - "SampleValues": [], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.SalesOrderHeader entity contains unique identifier values (GUIDs) that are used to ensure the distinct identification of each sales order record. These values follow the standard GUID format consisting of alphanumeric characters separated by hyphens. Each value is globally unique, providing a reliable way to distinguish records across distributed systems or databases.", - "Name": "rowguid", - "SampleValues": [ - "E68F7EE9-C581-45CD-9C4F-386AEDA74D84", - "A36EE74A-CF0D-4024-A1CE-4EAFFD1F85F0", - "BB3FEE84-C8BF-4DD2-BCCA-675AB6A11C38", - "ADDB8620-432A-456E-8470-1BEDD4BC3457", - "E3C189E7-98DE-4C40-B6C2-0D1D13F9BB33" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The column contains timestamp data representing the date and time when the sales order records were last modified. The values are formatted as date-time stamps in the format 'YYYY-MM-DD HH:MM:SS'. This information is crucial for tracking changes and maintaining data integrity within the sales order records.", - "Name": "ModifiedDate", - "SampleValues": [ - "2008-06-08 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.SalesOrderHeader entity contains detailed information about each sales order, including order dates, shipping details, status, and financial totals. It tracks important transactional data such as SalesOrderID, purchase and sales order numbers, customer and address identifiers, and payment-related fields. This entity can answer questions related to order tracking, financial performance per order, shipping methods, customer purchase history, and order processing times.", - "Entity": "SalesLT.SalesOrderHeader", - "EntityName": "Sales Order Summary" -} + "Entity": "SalesLT.SalesOrderHeader", + "Definition": "The SalesLT.SalesOrderHeader entity contains summarized information about each sales order, including details such as order dates, status, shipping information, customer identification, and financial totals. It helps track the progression of a sales order from creation to shipment and invoicing. This entity is useful for answering questions related to sales order processing, such as the status of an order, shipping methods used, customer order details, and the total due amounts for sales transactions.", + "EntityName": "Sales Order Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.SalesOrderDetail", + "ForeignKeys": [ + { + "Column": "SalesOrderID", + "ForeignColumn": "SalesOrderID" + } + ] + }, + { + "ForeignEntity": "SalesLT.Address", + "ForeignKeys": [ + { + "Column": "BillToAddressID", + "ForeignColumn": "AddressID" + }, + { + "Column": "ShipToAddressID", + "ForeignColumn": "AddressID" + } + ] + }, + { + "ForeignEntity": "SalesLT.Customer", + "ForeignKeys": [ + { + "Column": "CustomerID", + "ForeignColumn": "CustomerID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ], + "Columns": [ + { + "Name": "SalesOrderID", + "DataType": "int", + "Definition": "The SalesOrderID column in the SalesLT.SalesOrderHeader entity contains unique identifiers for sales orders. These identifiers are numeric and sequential, indicating that each sales order is assigned a unique number upon creation to track and manage individual sales transactions. The values do not follow any specific pattern other than being unique and incrementally assigned.", + "AllowedValues": null, + "SampleValues": [ + 71846, + 71832, + 71938, + 71897, + 71923 + ] + }, + { + "Name": "RevisionNumber", + "DataType": "tinyint", + "Definition": "The RevisionNumber column in the SalesLT.SalesOrderHeader entity contains integer values that indicate the number of times a sales order has been revised. This column is used to track changes or updates made to the original sales order after its initial creation. The values in this column help identify the version history of each sales order to maintain an accurate record of modifications. A higher number signifies more revisions have been made.", + "AllowedValues": null, + "SampleValues": [ + 2 + ] + }, + { + "Name": "OrderDate", + "DataType": "datetime", + "Definition": "The OrderDate column in the SalesLT.SalesOrderHeader entity contains the dates and times when sales orders were placed. The data follows the standard datetime format 'YYYY-MM-DD HH:MM:SS'. This column is used to record the precise date and time for each order, and it may be used for chronological sorting, filtering orders within specific time frames, or analyzing sales trends over time.", + "AllowedValues": null, + "SampleValues": [ + "2008-06-01 00:00:00" + ] + }, + { + "Name": "DueDate", + "DataType": "datetime", + "Definition": "The DueDate column in the SalesLT.SalesOrderHeader entity contains the date and time by which the sales order is due to be completed or delivered. The values in this column are in the datetime format 'YYYY-MM-DD HH:MM:SS'. This data assists in tracking when sales orders need to be fulfilled by, and ensures timely delivery or completion of orders. Notably, the time portion of the data often appears as '00:00:00', indicating that the primary focus is on the date rather than a specific time of day.", + "AllowedValues": null, + "SampleValues": [ + "2008-06-13 00:00:00" + ] + }, + { + "Name": "ShipDate", + "DataType": "datetime", + "Definition": "The ShipDate column in the SalesLT.SalesOrderHeader entity contains the date and time when the shipment of an order was processed. The values in this column are in the datetime format, typically in the YYYY-MM-DD HH:MI:SS layout. This column is used to track when orders have been shipped to customers.", + "AllowedValues": null, + "SampleValues": [ + "2008-06-08 00:00:00" + ] + }, + { + "Name": "Status", + "DataType": "tinyint", + "Definition": "The Status column in the SalesLT.SalesOrderHeader entity represents the current state or condition of the sales order. The values in this column are numeric codes, such as '5', that indicate different statuses of the sales order. These statuses are likely defined by a specific business logic which assigns meaning to each numeric code, identifying different stages in the sales order processing workflow.", + "AllowedValues": null, + "SampleValues": [ + 5 + ] + }, + { + "Name": "OnlineOrderFlag", + "DataType": "bit", + "Definition": "The OnlineOrderFlag column in the SalesLT.SalesOrderHeader entity indicates whether a sales order was placed online or not. The values are typically boolean, with 'True' representing orders placed online and 'False' representing orders not placed online. This column helps to identify the source of the sales order for tracking and analysis purposes.", + "AllowedValues": null, + "SampleValues": [ + false + ] + }, + { + "Name": "SalesOrderNumber", + "DataType": "nvarchar", + "Definition": "The SalesOrderNumber column in the SalesLT.SalesOrderHeader entity contains unique alphanumeric identifiers for sales orders. Each sales order number starts with the prefix 'SO' followed by a sequence of digits. This pattern ensures that each sales order can be individually tracked and referenced within the system. The column helps in uniquely identifying and managing sales orders within the database.", + "AllowedValues": null, + "SampleValues": [ + "SO71858", + "SO71936", + "SO71816", + "SO71885", + "SO71867" + ] + }, + { + "Name": "PurchaseOrderNumber", + "DataType": "nvarchar", + "Definition": "The PurchaseOrderNumber column in the SalesLT.SalesOrderHeader entity contains alphanumeric codes representing unique purchase order numbers assigned to each sales order. The values follow a pattern that starts with the prefix 'PO' followed by a sequence of digits. These purchase order numbers are used to track and reference sales transactions.", + "AllowedValues": null, + "SampleValues": [ + "PO29111718", + "PO3770176273", + "PO8671170385", + "PO10353140756", + "PO2697119362" + ] + }, + { + "Name": "AccountNumber", + "DataType": "nvarchar", + "Definition": "The AccountNumber column in the SalesLT.SalesOrderHeader entity contains alphanumeric identifiers for customer accounts. The values follow a specific pattern, typically consisting of a numeric sequence formatted as '10-4020-XXXXXX', where 'XXXXXX' is a unique six-digit number. This column is used to link sales orders to particular customer accounts within the system.", + "AllowedValues": null, + "SampleValues": [ + "10-4020-000649", + "10-4020-000223", + "10-4020-000502", + "10-4020-000276", + "10-4020-000609" + ] + }, + { + "Name": "CustomerID", + "DataType": "int", + "Definition": "The CustomerID column in the SalesLT.SalesOrderHeader entity contains unique numeric identifiers assigned to each customer. The values in this column are integers that uniquely distinguish one customer from another within the sales order header records. This column is used to link sales orders to the corresponding customer information. Each CustomerID represents a specific customer in the database.", + "AllowedValues": null, + "SampleValues": [ + 29975, + 30113, + 29531, + 29938, + 29584 + ] + }, + { + "Name": "ShipToAddressID", + "DataType": "int", + "Definition": "The ShipToAddressID column in the SalesLT.SalesOrderHeader entity contains unique identifier numbers for shipping addresses used in sales orders. These identifier numbers are likely assigned sequentially or based on some internal addressing schema. The column facilitates linking each sales order to a specific shipping address within the database. The values in this column are integers and do not follow any externally recognized standard.", + "AllowedValues": null, + "SampleValues": [ + 635, + 660, + 992, + 1086, + 649 + ] + }, + { + "Name": "BillToAddressID", + "DataType": "int", + "Definition": "The BillToAddressID column in the SalesLT.SalesOrderHeader entity contains integer values that represent unique identifiers for billing addresses associated with sales orders. Each value corresponds to a specific address recorded in a related address table. The integers are used to link the sales order records to their respective billing address records, ensuring accurate invoicing and customer identification.", + "AllowedValues": null, + "SampleValues": [ + 652, + 651, + 635, + 669, + 653 + ] + }, + { + "Name": "ShipMethod", + "DataType": "nvarchar", + "Definition": "The ShipMethod column in the SalesLT.SalesOrderHeader entity contains the names of shipping methods used for orders. The values represent different shipping options available for delivering products to customers. These values are generally descriptive and may include specific transport types or service levels provided by the shipping company. The values typically follow a pattern of descriptive shipping terms like \"CARGO TRANSPORT\" with added numerical identifiers to distinguish various methods.", + "AllowedValues": null, + "SampleValues": [ + "CARGO TRANSPORT 5" + ] + }, + { + "Name": "CreditCardApprovalCode", + "DataType": "varchar", + "Definition": "The CreditCardApprovalCode column in the SalesLT.SalesOrderHeader entity contains the approval codes received from credit card companies when a customer's credit card transaction is authorized. This column typically holds alphanumeric strings that represent the unique approval identifier for each transaction. These codes are used to verify that the credit card payment was successfully processed and authorized.", + "AllowedValues": null, + "SampleValues": [] + }, + { + "Name": "SubTotal", + "DataType": "money", + "Definition": "The SubTotal column in the SalesLT.SalesOrderHeader entity represents the total amount for a sales order before taxes and shipping are applied. The values in this column are numeric and likely represent monetary amounts with up to four decimal places, indicating precision in the currency calculation. This column is used to calculate the preliminary cost of an order, reflecting the aggregate price of all items included in the order.", + "AllowedValues": null, + "SampleValues": [ + "88812.8625", + "2453.7645", + "2137.2310", + "246.7392", + "74058.8078" + ] + }, + { + "Name": "TaxAmt", + "DataType": "money", + "Definition": "The TaxAmt column in the SalesLT.SalesOrderHeader entity contains the total tax amount applied to each sales order. The values are represented as decimal numbers with up to four decimal places. These amounts indicate the monetary tax applied to the sales order in the corresponding currency of the transaction.", + "AllowedValues": null, + "SampleValues": [ + "19.7391", + "1105.8967", + "8684.9465", + "91.3263", + "1014.8712" + ] + }, + { + "Name": "Freight", + "DataType": "money", + "Definition": "The Freight column in the SalesLT.SalesOrderHeader entity contains numerical values representing the freight cost associated with each sales order. The values are likely to be in a currency format, indicating the monetary amount charged for shipping and handling. This column includes a wide range of values, reflecting the variability in freight charges depending on factors such as order size, weight, and shipping method. The values can be fractional, showing precision in the cost calculations.", + "AllowedValues": null, + "SampleValues": [ + "60.3918", + "0.9738", + "1440.8659", + "61.3441", + "345.5927" + ] + }, + { + "Name": "TotalDue", + "DataType": "money", + "Definition": "The TotalDue column in the SalesLT.SalesOrderHeader entity contains the final amount payable for a sales order after all calculations, including taxes, discounts, and additional charges, have been applied. The values in this column are expressed as decimal numbers representing monetary amounts. It is used to track the total revenue generated from each sales order and is crucial for financial reporting and analysis.", + "AllowedValues": null, + "SampleValues": [ + "1170.5376", + "108597.9536", + "70698.9922", + "3293.7761", + "14017.9083" + ] + }, + { + "Name": "Comment", + "DataType": "nvarchar", + "Definition": "The Comment column in the SalesLT.SalesOrderHeader entity contains optional textual notes or remarks provided by customers or sales representatives about specific sales orders. This may include special instructions, delivery notes, or any other relevant information related to the order. The data in this column is typically used to provide additional context or details that are not covered by other columns in the sales order header.", + "AllowedValues": null, + "SampleValues": [] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.SalesOrderHeader entity contains unique identifier values in the UUID/GUID (Universally Unique Identifier/Globally Unique Identifier) format. Each value in this column is a 36-character string including hyphens, following the standard UUID format. This column is likely used to ensure distinctiveness and aid in the unique identification of each sales order record within the database.", + "AllowedValues": null, + "SampleValues": [ + "F1BE45A5-5C57-4A50-93C6-5F8BE44CB7CB", + "E3C189E7-98DE-4C40-B6C2-0D1D13F9BB33", + "7DB2329E-6446-42A8-8915-9C8370B68ED8", + "917EF5BA-F32D-4563-8588-66DB0BCDC846", + "BB3FEE84-C8BF-4DD2-BCCA-675AB6A11C38" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.SalesOrderHeader entity contains the timestamps of when each sales order record was last updated. The data is in the format 'YYYY-MM-DD HH:MM:SS'. This indicates the date and time when changes were made to the respective records in the sales order header. This column helps in tracking the modification history of the sales orders.", + "AllowedValues": null, + "SampleValues": [ + "2008-06-08 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.vGetAllCategories.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.vGetAllCategories.json index df27d95..9a778b1 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.vGetAllCategories.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.vGetAllCategories.json @@ -1,45 +1,49 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ParentProductCategoryName column in the SalesLT.vGetAllCategories entity contains the names of the primary categories of products. The values in this column categorize products into broad groups such as Components, Clothing, Bikes, and Accessories. This column helps in identifying and grouping related products under a common parent category.", - "Name": "ParentProductCategoryName", - "SampleValues": [ - "Components", - "Clothing", - "Bikes", - "Accessories" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The ProductCategoryName column in the SalesLT.vGetAllCategories entity contains names of product categories related to cycling accessories and equipment. This column includes various types of product categories such as frames, derailleurs, headsets, and other related items. The names are descriptive, indicating specific categories within the cycling industry.", - "Name": "ProductCategoryName", - "SampleValues": [ - "Mountain Frames", - "Derailleurs", - "Headsets", - "Pumps", - "Bottles and Cages" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The ProductCategoryID column in the SalesLT.vGetAllCategories entity contains numerical identifiers for different product categories. These IDs are unique integers assigned to each category to facilitate easy referencing in queries and reports. The values are distinct and correspond to various product categories within the dataset.", - "Name": "ProductCategoryID", - "SampleValues": [ - 24, - 31, - 10, - 16, - 39 - ], - "Type": "int" - } - ], - "Description": "The SalesLT.vGetAllCategories entity provides detailed information about product categories, including the names of parent product categories and specific product categories, along with their unique identification numbers. This entity is useful for retrieving comprehensive hierarchical data on product categories within a sales system. It can be especially helpful for questions related to product categorization, understanding category relationships, and organizing product data based on category hierarchy.", - "Entity": "SalesLT.vGetAllCategories", - "EntityName": "Product Categories Overview" -} + "Entity": "SalesLT.vGetAllCategories", + "Definition": "The SalesLT.vGetAllCategories entity contains information about product categories and their hierarchical relationships. It includes both parent and child product category names as well as unique identifiers for each product category. This entity can be used to answer questions related to the structure and organization of product categories, such as finding all subcategories under a specific parent category or identifying the parent category of a given product category.", + "EntityName": "Product Category Information", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [], + "CompleteEntityRelationshipsGraph": [], + "Columns": [ + { + "Name": "ParentProductCategoryName", + "DataType": "nvarchar", + "Definition": "The ParentProductCategoryName column in the SalesLT.vGetAllCategories entity contains the names of the primary categories for products. These categories are broad classifications that group related products together. Sample values indicate that the entries generally represent major product categories, such as Components, Clothing, Bikes, and Accessories. This column helps in identifying and organizing products at a high-level classification within the product hierarchy.", + "AllowedValues": null, + "SampleValues": [ + "Components", + "Clothing", + "Bikes", + "Accessories" + ] + }, + { + "Name": "ProductCategoryName", + "DataType": "nvarchar", + "Definition": "The ProductCategoryName column in the SalesLT.vGetAllCategories entity contains the names of various product categories. These category names represent different parts and accessories related to cycling, such as bike components and apparel. The values are descriptive and specific to the type of product or accessory they denote. This column helps in categorizing products for better organization and retrieval in the database.", + "AllowedValues": null, + "SampleValues": [ + "Fenders", + "Saddles", + "Handlebars", + "Bottom Brackets", + "Vests" + ] + }, + { + "Name": "ProductCategoryID", + "DataType": "int", + "Definition": "The ProductCategoryID column in the SalesLT.vGetAllCategories entity contains unique numeric identifiers assigned to different product categories. Each number corresponds to a specific category such as clothing, accessories, or equipment. These identifiers are used to distinguish and organize products into their respective categories within the database.", + "AllowedValues": null, + "SampleValues": [ + 39, + 38, + 17, + 41, + 36 + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductAndDescription.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductAndDescription.json index dc66371..315c3c4 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductAndDescription.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductAndDescription.json @@ -1,72 +1,76 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ProductID column in the SalesLT.vProductAndDescription entity contains unique numerical identifiers for products. These IDs are integers and are used to distinctly identify each product within the database. Each ProductID is unique to a particular product and is used to join with other tables, retrieve specific product details, and manage inventory or sales data.", - "Name": "ProductID", - "SampleValues": [ - 995, - 736, - 846, - 923, - 818 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The Name column in the SalesLT.vProductAndDescription entity contains the names of various products. The product names include specific details such as model, color, size, and type. The naming convention often includes a combination of letters and numbers, and can include descriptors such as colors and sizes. This pattern indicates that each name is descriptive and provides pertinent information about the product's key attributes.", - "Name": "Name", - "SampleValues": [ - "HL Mountain Frame - Silver, 46", - "LL Touring Handlebars", - "Road-650 Black, 52", - "Touring-1000 Yellow, 46", - "LL Headset" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The ProductModel column in the SalesLT.vProductAndDescription entity contains the names of product models in a textual format. Each product model name typically describes a specific type of product or component associated with bicycles and biking accessories. The values often include descriptors such as the product type and may contain prefixes indicating specific lines or categories, such as \"HL\" and \"LL.\" This column helps in categorizing and identifying different bicycle-related products within the database.", - "Name": "ProductModel", - "SampleValues": [ - "HL Crankset", - "Fender Set - Mountain", - "Mountain Bike Socks", - "LL Mountain Handlebars", - "HL Mountain Rear Wheel" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Culture column in the SalesLT.vProductAndDescription entity contains culture or language codes that follow a standard format, often used to represent linguistic and cultural settings. These codes can be either two-letter ISO 639-1 language codes or combinations that include additional specificity such as regional dialects or script variations. Examples include 'he' for Hebrew, 'fr' for French, 'zh-cht' for traditional Chinese, 'en' for English, and 'th' for Thai. This data is used to denote the language or cultural context applicable to product descriptions.", - "Name": "Culture", - "SampleValues": [ - "he ", - "fr ", - "zh-cht", - "en ", - "th " - ], - "Type": "nchar" - }, - { - "AllowedValues": null, - "Definition": "The Description column in the SalesLT.vProductAndDescription entity contains detailed product descriptions in various languages. These descriptions provide specific information about the product\u2019s material, design, and features. The data may include technical specifications, usage instructions, and benefits, catering to international customers by offering descriptions in multiple languages.", - "Name": "Description", - "SampleValues": [ - "\u0e2a\u0e23\u0e49\u0e32\u0e07\u0e08\u0e32\u0e01\u0e2d\u0e25\u0e39\u0e21\u0e34\u0e40\u0e19\u0e35\u0e22\u0e21\u0e2d\u0e31\u0e25\u0e25\u0e2d\u0e22\u0e0a\u0e19\u0e34\u0e14\u0e40\u0e14\u0e35\u0e22\u0e27\u0e01\u0e31\u0e1a\u0e2a\u0e38\u0e14\u0e22\u0e2d\u0e14\u0e40\u0e1f\u0e23\u0e21 HL \u0e40\u0e1f\u0e23\u0e21 ML \u0e19\u0e35\u0e49\u0e21\u0e35\u0e19\u0e49\u0e33\u0e2b\u0e19\u0e31\u0e01\u0e40\u0e1a\u0e32 \u0e2a\u0e23\u0e49\u0e32\u0e07\u0e02\u0e36\u0e49\u0e19\u0e15\u0e32\u0e21\u0e02\u0e19\u0e32\u0e14\u0e17\u0e35\u0e48\u0e43\u0e2b\u0e49\u0e04\u0e27\u0e32\u0e21\u0e41\u0e02\u0e47\u0e07\u0e41\u0e01\u0e23\u0e48\u0e07\u0e40\u0e1b\u0e47\u0e19\u0e40\u0e25\u0e34\u0e28 \u0e40\u0e27\u0e2d\u0e23\u0e4c\u0e0a\u0e31\u0e19\u0e2a\u0e33\u0e2b\u0e23\u0e31\u0e1a\u0e2a\u0e38\u0e20\u0e32\u0e1e\u0e2a\u0e15\u0e23\u0e35", - "\u05d3\u05d5\u05d5\u05e9\u05d5\u05ea \u05dc\u05dc\u05d0 \u05d7\u05d1\u05e7\u05d9\u05dd \u2013 \u05d0\u05dc\u05d5\u05de\u05d9\u05e0\u05d9\u05d5\u05dd.", - "\u0e2d\u0e2d\u0e01\u0e41\u0e1a\u0e1a\u0e40\u0e1e\u0e37\u0e48\u0e2d\u0e04\u0e27\u0e32\u0e21\u0e2a\u0e30\u0e14\u0e27\u0e01 \u0e02\u0e19\u0e32\u0e14\u0e01\u0e30\u0e17\u0e31\u0e14\u0e23\u0e31\u0e14 \u0e43\u0e2a\u0e48\u0e1e\u0e2d\u0e14\u0e35\u0e01\u0e23\u0e30\u0e40\u0e1b\u0e4b\u0e32 \u0e01\u0e23\u0e30\u0e1a\u0e2d\u0e01\u0e2d\u0e25\u0e39\u0e21\u0e34\u0e40\u0e19\u0e35\u0e22\u0e21 \u0e02\u0e19\u0e32\u0e14 160psi", - "Conception robuste permettant d'absorber les chocs et d'offrir une conduite plus pr\u00e9cise.", - "\u05d7\u05e8\u05d9\u05e6\u05d9 \u05e6\u05de\u05d9\u05d2 \u05d6\u05d4\u05d9\u05dd \u05dc\u05d0\u05dc\u05d4 \u05d4\u05de\u05e6\u05d5\u05d9\u05d9\u05dd \u05d1\u05e6\u05de\u05d9\u05d2\u05d9\u05dd \u05d9\u05e7\u05e8\u05d9\u05dd \u05d9\u05d5\u05ea\u05e8, \u05d0\u05d5\u05dc\u05dd \u05e2\u05dd \u05d9\u05e6\u05d9\u05e7\u05ea \u05ea\u05d9\u05dc\u05d9 \u05e6\u05de\u05d9\u05d2 \u05d9\u05e7\u05e8\u05d4 \u05e4\u05d7\u05d5\u05ea." - ], - "Type": "nvarchar" - } - ], - "Description": "The SalesLT.vProductAndDescription entity provides detailed information about products including their ID, name, model, and descriptions in different cultures. It is useful for retrieving product details such as names and descriptions for various languages or cultural contexts. This entity is ideal for answering questions related to product information and multilingual product descriptions.", - "Entity": "SalesLT.vProductAndDescription", - "EntityName": "Product and Description Data" -} + "Entity": "SalesLT.vProductAndDescription", + "Definition": "The SalesLT.vProductAndDescription entity provides a comprehensive view of product information along with their descriptions in different cultures. It includes details such as the product ID and name, the product model, the culture code indicating the language or region, and the product description tailored to that particular culture. This entity is useful for questions related to product details, multilingual product descriptions, and product model information.", + "EntityName": "Product Information and Descriptions", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [], + "CompleteEntityRelationshipsGraph": [], + "Columns": [ + { + "Name": "ProductID", + "DataType": "int", + "Definition": "The ProductID column in the SalesLT.vProductAndDescription entity contains unique numeric identifiers for each product. The values in this column are whole numbers that serve as primary keys to distinguish individual products in the database. Each number corresponds to a specific product's details and description within the SalesLT.vProductAndDescription entity.", + "AllowedValues": null, + "SampleValues": [ + 995, + 889, + 904, + 909, + 724 + ] + }, + { + "Name": "Name", + "DataType": "nvarchar", + "Definition": "The Name column in the SalesLT.vProductAndDescription entity contains descriptive names of various products. The values include specific product details such as type, model, color, and size. These names are typically composed of multiple parts describing different attributes of the product, often separated by commas or hyphens. The data in this column helps identify and differentiate products based on their unique features and specifications.", + "AllowedValues": null, + "SampleValues": [ + "Rear Derailleur", + "Sport-100 Helmet, Red", + "HL Road Frame - Red, 58", + "ML Road Frame - Red, 58", + "LL Road Rear Wheel" + ] + }, + { + "Name": "ProductModel", + "DataType": "nvarchar", + "Definition": "The ProductModel column in the SalesLT.vProductAndDescription entity contains the names of various product models sold. Each value represents the model name of a product, which can include different types of items such as bicycles and bicycle components. The values are descriptive and may include combinations of letters, numbers, and hyphens to distinguish between different product models. The names are specific and indicative of the product's type or series within a broader category.", + "AllowedValues": null, + "SampleValues": [ + "All-Purpose Bike Stand", + "Road-450", + "LL Crankset", + "Mountain-200", + "LL Headset" + ] + }, + { + "Name": "Culture", + "DataType": "nchar", + "Definition": "The Culture column in the SalesLT.vProductAndDescription entity contains language codes that identify the culture or locale associated with product descriptions. The values follow a pattern of two-letter lowercase codes, which likely correspond to the ISO 639-1 standard for language codes. Examples include 'ar' for Arabic, 'en' for English, 'th' for Thai, 'he' for Hebrew, and 'fr' for French. These codes are used to localize product information for different regions and languages.", + "AllowedValues": null, + "SampleValues": [ + "ar ", + "en ", + "th ", + "he ", + "fr " + ] + }, + { + "Name": "Description", + "DataType": "nvarchar", + "Definition": "The Description column in the SalesLT.vProductAndDescription entity contains detailed textual descriptions of various products. These descriptions provide information about the features, specifications, and unique selling points of the products. The values in this column are multilingual, indicating that the product descriptions are available in different languages, catering to a diverse customer base.", + "AllowedValues": null, + "SampleValues": [ + "High-performance carbon road fork with curved legs.", + "Chaque cadre est fabriqu\u00e9 artisanalement dans notre atelier de Bordeaux afin d'obtenir le diam\u00e8tre et l'\u00e9paisseur adapt\u00e9s \u00e0 un v\u00e9lo tout-terrain de premier choix. Le cadre en aluminium soud\u00e9 \u00e0 chaud pr\u00e9sente un tube d'un plus grand diam\u00e8tre, afin d'absorber les bosses.", + "\u0e1b\u0e23\u0e30\u0e2a\u0e34\u0e17\u0e18\u0e34\u0e20\u0e32\u0e1e\u0e01\u0e32\u0e23\u0e40\u0e1b\u0e25\u0e35\u0e48\u0e22\u0e19\u0e40\u0e01\u0e35\u0e22\u0e23\u0e4c\u0e17\u0e35\u0e48\u0e40\u0e2b\u0e19\u0e37\u0e2d\u0e01\u0e27\u0e48\u0e32", + "\u05de\u05db\u05e0\u05e1\u05d9 \u05d2\u05d1\u05e8\u05d9\u05dd \u05e7\u05e6\u05e8\u05d9\u05dd \u05dc\u05ea\u05d7\u05e8\u05d5\u05d9\u05d5\u05ea, 8 \u05d7\u05dc\u05e7\u05d9\u05dd \u2013 \u05e2\u05e9\u05d5\u05d9\u05d9\u05dd \u05e1\u05e4\u05e0\u05d3\u05e7\u05e1 \u05e2\u05dd \u05d7\u05d2\u05d5\u05e8\u05d4 \u05d0\u05dc\u05e1\u05d8\u05d9\u05ea \u05d5\u05d4\u05d9\u05d3\u05d5\u05e7 \u05e8\u05d2\u05dc\u05d9\u05d9\u05dd.", + "\u0e08\u0e38\u0e4a\u0e1a\u0e22\u0e32\u0e07\u0e1c\u0e19\u0e36\u0e01\u0e14\u0e49\u0e27\u0e22\u0e15\u0e19\u0e40\u0e2d\u0e07" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductModelCatalogDescription.json b/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductModelCatalogDescription.json index aa6753f..14410f9 100644 --- a/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductModelCatalogDescription.json +++ b/text_2_sql/data_dictionary/generated_samples/SalesLT.vProductModelCatalogDescription.json @@ -1,288 +1,292 @@ { - "Columns": [ - { - "AllowedValues": null, - "Definition": "The ProductModelID column in the SalesLT.vProductModelCatalogDescription entity contains unique identifiers for product models. Each ProductModelID is an integer value that references a specific model of a product in the database. This column is used to associate catalog descriptions with their corresponding product models. The values are numeric and typically correspond to product models within the database's defined range.", - "Name": "ProductModelID", - "SampleValues": [ - 28, - 23, - 34, - 35, - 19 - ], - "Type": "int" - }, - { - "AllowedValues": null, - "Definition": "The Name column in the SalesLT.vProductModelCatalogDescription entity contains product model names primarily related to various types of bicycles. The naming pattern includes the type of bicycle (e.g., Road, Mountain, Touring) followed by a numeric designation, which likely indicates the model number or series. The values appear to be descriptive identifiers that uniquely distinguish different bicycle models.", - "Name": "Name", - "SampleValues": [ - "Road-450", - "Mountain-100", - "Mountain-500", - "Road-150", - "Touring-1000" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Summary column in the SalesLT.vProductModelCatalogDescription entity contains brief descriptive texts about various bikes. These descriptions highlight key features, unique selling points, and benefits of the bikes, often focusing on aspects such as design, performance, comfort, and versatility. The text often mentions specific components and qualities like aerodynamic design, lightweight frames, smooth suspension, and broad gear ranges, catering to both competitive and casual riders.", - "Name": "Summary", - "SampleValues": [ - "A true multi-sport bike that offers streamlined riding and a revolutionary design. Aerodynamic design lets you ride with the pros, and the gearing will conquer hilly roads. ", - "Our top-of-the-line competition mountain bike. Performance-enhancing options include the innovative HL Frame,super-smooth front suspension, and traction for all terrain. ", - "This bike is ridden by race winners. Developed with theAdventure Works Cycles professional race team, it has a extremely lightheat-treated aluminum frame, and steering that allows precision control. ", - "Travel in style and comfort. Designed for maximum comfort and safety.Wide gear range takes on all hills. High-tech aluminum alloy construction provides durability without added weight. ", - "Suitable for any type of riding, on or off-road.Fits any budget. Smooth-shifting with a comfortable ride. " - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Manufacturer column in the SalesLT.vProductModelCatalogDescription entity contains the names of companies or brands that produce the products listed. In the provided sample, the value 'AdventureWorks' suggests that the manufacturer names might be specific to brands associated with AdventureWorks or similar companies. The column is likely to contain consistent naming conventions for different manufacturers within the context of the product catalog descriptions.", - "Name": "Manufacturer", - "SampleValues": [ - "AdventureWorks" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The column contains copyright information associated with product model catalog descriptions. The data typically includes the year of copyright in a four-digit format (e.g., 2002). This suggests that the column tracks the year when the catalog description was copyrighted.", - "Name": "Copyright", - "SampleValues": [ - "2002" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The ProductURL column in the SalesLT.vProductModelCatalogDescription entity contains URL links to product pages. These links are designed to provide online access to detailed information about the products. The URLs typically adhere to a common structure, indicating they are hosted on the Adventure Works website.", - "Name": "ProductURL", - "SampleValues": [ - "HTTP://www.Adventure-works.com" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The WarrantyPeriod column in the SalesLT.vProductModelCatalogDescription entity contains the duration of the warranty offered for each product. The values are expressed in years, indicating the number of years a product is covered under warranty. The format follows a numeric value followed by the word \"years\" or \"year\" for a single year.", - "Name": "WarrantyPeriod", - "SampleValues": [ - "4 years", - "3 years", - "1 year" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The WarrantyDescription column in the SalesLT.vProductModelCatalogDescription entity contains textual descriptions of warranty coverage associated with various products. These descriptions typically include terms such as 'parts and labor,' indicating the scope of warranty service provided. The value provides customers with details on what aspects of the product are covered under the warranty terms.", - "Name": "WarrantyDescription", - "SampleValues": [ - "parts and labor" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The NoOfYears column in the SalesLT.vProductModelCatalogDescription entity contains the duration in years associated with a product model's warranty or lifespan. The values are represented as a number followed by the word \"years,\" indicating the time frame in years. Each entry specifies the number of years, such as \"7 years\" or \"3 years,\" reflecting the warranty or expected lifespan of the product model.", - "Name": "NoOfYears", - "SampleValues": [ - "7 years", - "5 years", - "3 years", - "10 years" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The MaintenanceDescription column in the SalesLT.vProductModelCatalogDescription entity contains textual descriptions related to the availability of maintenance contracts for products. These descriptions typically inform the customer about the option to obtain maintenance services through dealers or retail stores. The text often mentions specific points of contact or locations where maintenance services can be arranged, such as dealers or AdventureWorks retail stores.", - "Name": "MaintenanceDescription", - "SampleValues": [ - "maintenance contract available through your dealer or any AdventureWorks retail store.", - "maintenance contact available through dealer or any Adventure Works Cycles retail store.", - "maintenance contact available through dealer" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Wheel column in the SalesLT.vProductModelCatalogDescription entity contains textual descriptions of various types of wheels. The descriptions highlight specific features and benefits of the wheels, such as strength, stability, performance, aerodynamics, and materials used. The content is geared towards providing potential customers with detailed information about the quality and specifications of the wheels, which may include details about rims, spokes, and tires.", - "Name": "Wheel", - "SampleValues": [ - "Strong wheels with double-walled rims.", - "Stable, durable wheels suitable for novice riders.", - "High performance wheels.", - "Excellent aerodynamic rims guarantee a smooth ride.", - "Aluminum alloy rim with stainless steel spokes; built for speed on our high quality rubber tires." - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Saddle column in the SalesLT.vProductModelCatalogDescription entity contains text descriptions of different types of bicycle saddles. These descriptions highlight various features and qualities of the saddles such as comfort, material composition, weight, and design improvements for enhanced riding experiences. The text typically includes specifics about the saddle's construction, like materials used and benefits provided to the rider, such as pressure relief or impact absorption.", - "Name": "Saddle", - "SampleValues": [ - "Cut-out shell for a more comfortable ride.", - "Comfortable saddle with bump absorping rubber bumpers.", - "Lightweight kevlar racing saddle.", - "New design relieves pressure for long rides.", - "Made from synthetic leather and features gel padding for increased comfort." - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Pedal column in the SalesLT.vProductModelCatalogDescription entity contains descriptive text detailing the features and characteristics of different bicycle pedals. These descriptions highlight various features such as adjustability, platform size, and stability, which cater to different types of riding needs and preferences. The information is presented in a sentence format, offering insight into the specific benefits and uses of each pedal model.", - "Name": "Pedal", - "SampleValues": [ - "Top-of-the-line clipless pedals with adjustable tension.", - "Expanded platform so you can ride in any shoes; great for all-around riding.", - "A stable pedal for all-day riding." - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The BikeFrame column in the SalesLT.vProductModelCatalogDescription entity contains detailed descriptions of bike frames, focusing on their material, construction, and performance attributes. The descriptions mention characteristics such as custom shaping, strength, lightweight design, welding and heat treatment, and specific manufacturing techniques. The information is aimed at highlighting the quality and technological innovations of the bike frames, which are typically made from aluminum alloy.", - "Name": "BikeFrame", - "SampleValues": [ - "The aluminum frame is custom-shaped for both good looks and strength;it will withstand the most rigorous challenges of daily riding.", - "Our lightest and best quality aluminum frame made from the newest alloy;it is welded and heat-treated for strength.Our innovative design results in maximum comfort and performance.", - "Our best value frame utilizing the same, ground-breaking technology as the ML aluminum frame.", - "Each frame is hand-crafted in our Bothell facility to the optimum diameterand wall-thickness required of a premium mountain frame.The heat-treated welded aluminum frame has a larger diameter tube that absorbs the bumps.", - "aluminum alloy frame and features a lightweight down-tube milled to the perfect diameter for optimal strength." - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Crankset column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of the crankset components of bicycles. These descriptions typically highlight specific features and qualities of the crankset, such as materials used (e.g., aluminum), attributes like rigidity and strength, and performance aspects such as shifting capabilities. The information in this column is used to inform potential buyers about the key characteristics of the crankset.", - "Name": "Crankset", - "SampleValues": [ - " Triple crankset; alumunim crank arm; flawless shifting. ", - " Super rigid spindle. ", - " High-strength crank arm. " - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The PictureAngle column in the SalesLT.vProductModelCatalogDescription entity contains values that indicate the angle from which a product picture is taken. For example, a common value is 'front,' suggesting the image is taken from the front view of the product. This column helps specify the perspective of the product images used in the catalog, aiding in visual representation for customers.", - "Name": "PictureAngle", - "SampleValues": [ - "front" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The PictureSize column in the SalesLT.vProductModelCatalogDescription entity contains text values indicating the size category of product images. The sample value \"small\" suggests that this column likely categorizes image sizes into predefined types, such as \"small,\" \"medium,\" or \"large.\" This categorization helps in identifying and filtering products based on the size of their images in the catalog.", - "Name": "PictureSize", - "SampleValues": [ - "small" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The ProductPhotoID column in the SalesLT.vProductModelCatalogDescription entity contains unique numeric identifiers for product photos. Each identifier corresponds to a specific product image within the catalog, allowing for the association of visual representations with product models. The values are integers and do not follow a particular sequence, indicating that each product photo is assigned a distinct ID.", - "Name": "ProductPhotoID", - "SampleValues": [ - "87", - "126", - "118", - "111", - "1" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Material column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of the materials used in product manufacturing. The values often include types of metals such as Aluminum and specific alloys. The column entries typically consist of concise material specifications, sometimes with slight variations in naming conventions.", - "Name": "Material", - "SampleValues": [ - "Aluminum Alloy", - "Aluminum", - "Almuminum Alloy" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Color column in the SalesLT.vProductModelCatalogDescription entity contains descriptive text indicating the range of colors available for a product. The descriptions often emphasize the variety of colors, such as availability in most colors or all colors, and may occasionally specify exceptions or exclusions. These values provide a general overview of color options for product models without listing specific colors.", - "Name": "Color", - "SampleValues": [ - "Available in most colors.", - "Available in most colors", - "Available in all colors.", - "Available in all colors except metallic." - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The ProductLine column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of different types of bicycles offered. The values indicate the category of the bike, such as Touring bike, Road bike, and Mountain bike. These descriptive names are used to classify the products into specific categories based on their intended use and features.", - "Name": "ProductLine", - "SampleValues": [ - "Touring bike", - "Road bike", - "Mountain bike" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The Style column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of the target audience for the products, likely indicating the gender demographic. Common values include terms like 'Unisex' and 'Men's', which suggest the product's intended market segment. These values help in categorizing and filtering products based on the gender suitability of the merchandise.", - "Name": "Style", - "SampleValues": [ - "Unisex", - "Men's" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The RiderExperience column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of riders' skill levels that a particular product is suitable for. These values typically range from novice to professional, indicating a progression in skill proficiency. The column uses a combination of words like \"Novice,\" \"Intermediate,\" \"Advanced,\" and \"Professional\" to categorize the riding experience levels.", - "Name": "RiderExperience", - "SampleValues": [ - "Novice to Intermediate riders", - "Novice to Advanced riders", - "Intermediate to Professional riders", - "Intermediate to Advanced riders", - "Advanced to Professional riders" - ], - "Type": "nvarchar" - }, - { - "AllowedValues": null, - "Definition": "The rowguid column in the SalesLT.vProductModelCatalogDescription entity contains unique identifier values in the GUID (Globally Unique Identifier) format. These values are used to uniquely distinguish each row in the table, ensuring that each entry can be identified independently of others. The format follows the standard 8-4-4-4-12 pattern, common for GUIDs.", - "Name": "rowguid", - "SampleValues": [ - "AA10D9E6-E33F-4DA8-ACE1-992FCD6BB171", - "FCA0665B-B956-489A-A5EC-6F0B4AA14D02", - "8456BB94-B4DD-4A47-A76B-D0E54AB4285D", - "94FFB702-0CBC-4E3F-B840-C51F0D11C8F6", - "52E7F2C1-DBFF-4518-927D-C7D46F9ED32E" - ], - "Type": "uniqueidentifier" - }, - { - "AllowedValues": null, - "Definition": "The ModifiedDate column in the SalesLT.vProductModelCatalogDescription entity contains timestamps indicating the date and time when each record was last modified. The format follows standard SQL datetime structure, which includes both date and time details down to fractional seconds. This column is used to track and manage updates to the catalog descriptions of product models.", - "Name": "ModifiedDate", - "SampleValues": [ - "2006-11-20 09:56:38.273000", - "2005-06-01 00:00:00" - ], - "Type": "datetime" - } - ], - "Description": "The SalesLT.vProductModelCatalogDescription entity includes detailed information about various product models, such as their names, summaries, manufacturers, and warranty details. It also covers specifications like wheel type, saddle, pedal, bike frame, and crankset, along with visual attributes like picture angle, size, and product photos. This entity is useful for answering questions related to the description, warranty, and physical features of different product models, providing insights into product specifications and visual representations.", - "Entity": "SalesLT.vProductModelCatalogDescription", - "EntityName": "Product Model Catalog Descriptions" -} + "Entity": "SalesLT.vProductModelCatalogDescription", + "Definition": "The SalesLT.vProductModelCatalogDescription entity contains detailed descriptions and catalog-specific information about different product models. It includes various attributes such as product names, summaries, manufacturer details, warranty information, maintenance descriptions, and specific features related to bike components. Additionally, it offers visual details like picture angles and sizes, along with meta information such as the date of last modification and unique identifiers. This entity can be used to answer questions related to the detailed characteristics and specifications of products, including their warranty and maintenance information, as well as visual and style attributes.", + "EntityName": "Product Model Catalog Description", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [], + "CompleteEntityRelationshipsGraph": [], + "Columns": [ + { + "Name": "ProductModelID", + "DataType": "int", + "Definition": "The ProductModelID column in the SalesLT.vProductModelCatalogDescription entity contains numerical identifiers for different product models. These identifiers are used to uniquely distinguish each product model within the database. The values are integers and each number corresponds to a specific product model entry. This column is essential for linking product models to their respective descriptions in the catalog.", + "AllowedValues": null, + "SampleValues": [ + 34, + 28, + 35, + 25, + 23 + ] + }, + { + "Name": "Name", + "DataType": "nvarchar", + "Definition": "The Name column in the SalesLT.vProductModelCatalogDescription entity contains the names of various product models. The names typically consist of a descriptor followed by a numerical value, which likely indicates the specific model or version of the product. These descriptors often pertain to the type or category of the product, such as \"Touring,\" \"Road,\" or \"Mountain.\"", + "AllowedValues": null, + "SampleValues": [ + "Touring-2000", + "Road-450", + "Mountain-500", + "Touring-1000", + "Road-150" + ] + }, + { + "Name": "Summary", + "DataType": "nvarchar", + "Definition": "The Summary column in the SalesLT.vProductModelCatalogDescription entity contains descriptive text summing up the features and benefits of various bicycle models. The summaries highlight key selling points such as design, comfort, performance, and specific components used in each bike. The descriptions are detailed and aim to entice potential customers by emphasizing the unique qualities of each bike model, including aspects like frame material, suspension, gear range, and additional accessories. These summaries are tailored to appeal to a wide range of customers, whether they are looking for competitive racing bikes or comfortable travel bicycles.", + "AllowedValues": null, + "SampleValues": [ + "Our top-of-the-line competition mountain bike. Performance-enhancing options include the innovative HL Frame,super-smooth front suspension, and traction for all terrain. ", + "Travel in style and comfort. Designed for maximum comfort and safety.Wide gear range takes on all hills. High-tech aluminum alloy construction provides durability without added weight. ", + "Suitable for any type of riding, on or off-road.Fits any budget. Smooth-shifting with a comfortable ride. ", + "This bike is ridden by race winners. Developed with theAdventure Works Cycles professional race team, it has a extremely lightheat-treated aluminum frame, and steering that allows precision control. ", + "The plush custom saddle keeps you riding all day, and there's plenty of space to add panniers and bike bags to the newly-redesigned carrier.This bike has great stability when fully-loaded. " + ] + }, + { + "Name": "Manufacturer", + "DataType": "nvarchar", + "Definition": "The Manufacturer column in the SalesLT.vProductModelCatalogDescription entity contains the names of companies that produce or assemble the products listed in the catalog. In the provided sample, the value is \"AdventureWorks,\" which suggests that this column stores the brand or company name responsible for manufacturing the products. The Manufacturer field likely holds text values that identify different manufacturers associated with various product models in the catalog.", + "AllowedValues": null, + "SampleValues": [ + "AdventureWorks" + ] + }, + { + "Name": "Copyright", + "DataType": "nvarchar", + "Definition": "The Copyright column in the SalesLT.vProductModelCatalogDescription entity contains the copyright year of the product model catalog description. The values reflect the year when the copyright was established, presented in a four-digit numerical format. This indicates the time period during which the intellectual property rights for the catalog description were secured.", + "AllowedValues": null, + "SampleValues": [ + "2002" + ] + }, + { + "Name": "ProductURL", + "DataType": "nvarchar", + "Definition": "The ProductURL column in the SalesLT.vProductModelCatalogDescription entity contains URLs that link to product pages on the Adventure Works website. The values in this column follow the standard URL format, beginning with 'HTTP://' or 'HTTPS://', followed by the domain name 'www.Adventure-works.com'. This column is used to provide direct access to more detailed information about each product model on the company's website.", + "AllowedValues": null, + "SampleValues": [ + "HTTP://www.Adventure-works.com" + ] + }, + { + "Name": "WarrantyPeriod", + "DataType": "nvarchar", + "Definition": "The WarrantyPeriod column in the SalesLT.vProductModelCatalogDescription entity contains information about the length of the warranty period for products. The values are expressed as a combination of a numerical value and the word \"year\" or \"years,\" indicating the duration of the warranty in years. This suggests that warranty periods are provided in whole years rather than partial years or other units of time. The data helps determine how long a product is covered under warranty.", + "AllowedValues": null, + "SampleValues": [ + "4 years", + "3 years", + "1 year" + ] + }, + { + "Name": "WarrantyDescription", + "DataType": "nvarchar", + "Definition": "The WarrantyDescription column in the SalesLT.vProductModelCatalogDescription entity contains text descriptions of the warranties associated with different product models. These descriptions typically explain the scope of coverage, such as what parts and services are included under the warranty terms. The descriptions may vary in length and detail, but generally outline the protections and benefits that come with the purchase of the product. Common inclusions in these descriptions are mentions of parts and labor coverage.", + "AllowedValues": null, + "SampleValues": [ + "parts and labor" + ] + }, + { + "Name": "NoOfYears", + "DataType": "nvarchar", + "Definition": "The NoOfYears column in the SalesLT.vProductModelCatalogDescription entity contains the duration or lifespan information of a product model, typically indicated in years. The values in this column follow a format that includes a numeric value followed by the word \"years.\" This column helps identify the length of time a product model is associated with or has been in the catalog.", + "AllowedValues": null, + "SampleValues": [ + "7 years", + "5 years", + "3 years", + "10 years" + ] + }, + { + "Name": "MaintenanceDescription", + "DataType": "nvarchar", + "Definition": "The MaintenanceDescription column in the SalesLT.vProductModelCatalogDescription entity contains descriptive text regarding the maintenance options and services available for products. The descriptions typically mention the availability of maintenance contracts through dealers or retail stores associated with AdventureWorks. The text may vary slightly but consistently communicates where and how maintenance support can be obtained.", + "AllowedValues": null, + "SampleValues": [ + "maintenance contract available through your dealer or any AdventureWorks retail store.", + "maintenance contact available through dealer or any Adventure Works Cycles retail store.", + "maintenance contact available through dealer" + ] + }, + { + "Name": "Wheel", + "DataType": "nvarchar", + "Definition": "The Wheel column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of wheel-related features and specifications for different product models. These descriptions highlight aspects such as durability, performance, material composition, and suitability for various rider experience levels. The information is geared towards providing detailed insights into the quality and characteristics of the wheels used in the products.", + "AllowedValues": null, + "SampleValues": [ + "Strong wheels with double-walled rims.", + "Stable, durable wheels suitable for novice riders.", + "High performance wheels.", + "Excellent aerodynamic rims guarantee a smooth ride.", + "Aluminum alloy rim with stainless steel spokes; built for speed on our high quality rubber tires." + ] + }, + { + "Name": "Saddle", + "DataType": "nvarchar", + "Definition": "The Saddle column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of bicycle saddles. The descriptions highlight features such as the material used, comfort enhancements, design innovations, and weight specifications. These entries tend to focus on attributes that improve the riding experience, including padding, pressure relief, and lightweight construction.", + "AllowedValues": null, + "SampleValues": [ + "Made from synthetic leather and features gel padding for increased comfort.", + "New design relieves pressure for long rides.", + "Cut-out shell for a more comfortable ride.", + "Comfortable saddle with bump absorping rubber bumpers.", + "Lightweight kevlar racing saddle." + ] + }, + { + "Name": "Pedal", + "DataType": "nvarchar", + "Definition": "The Pedal column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of different types of bicycle pedals. These descriptions highlight the specific features, advantages, and uses of each pedal type, such as clipless pedals with adjustable tension, platforms suitable for various shoe types, and stability for all-day riding. The information is provided in sentence form, detailing the product's unique selling points and designed purpose.", + "AllowedValues": null, + "SampleValues": [ + "Top-of-the-line clipless pedals with adjustable tension.", + "Expanded platform so you can ride in any shoes; great for all-around riding.", + "A stable pedal for all-day riding." + ] + }, + { + "Name": "BikeFrame", + "DataType": "nvarchar", + "Definition": "The BikeFrame column in the SalesLT.vProductModelCatalogDescription entity contains textual descriptions of the bicycle frames used in different product models. These descriptions highlight various attributes such as material (e.g., aluminum), quality, construction techniques (e.g., welded and heat-treated), design benefits (e.g., strength, comfort, performance), and specific manufacturing processes (e.g., hand-crafted parts). The entries emphasize the unique features and technological advancements of each bike frame to appeal to potential buyers.", + "AllowedValues": null, + "SampleValues": [ + "The aluminum frame is custom-shaped for both good looks and strength;it will withstand the most rigorous challenges of daily riding.", + "Our lightest and best quality aluminum frame made from the newest alloy;it is welded and heat-treated for strength.Our innovative design results in maximum comfort and performance.", + "Our best value frame utilizing the same, ground-breaking technology as the ML aluminum frame.", + "Each frame is hand-crafted in our Bothell facility to the optimum diameterand wall-thickness required of a premium mountain frame.The heat-treated welded aluminum frame has a larger diameter tube that absorbs the bumps.", + "aluminum alloy frame and features a lightweight down-tube milled to the perfect diameter for optimal strength." + ] + }, + { + "Name": "Crankset", + "DataType": "nvarchar", + "Definition": "The Crankset column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of the crankset features for various product models. The values include specific attributes and qualities of the crankset, such as materials, construction, and performance characteristics. Each value provides a brief, descriptive phrase highlighting key selling points or technical details of the crankset. The descriptions are typically short phrases that emphasize aspects like durability, rigidity, and functionality.", + "AllowedValues": null, + "SampleValues": [ + " Triple crankset; alumunim crank arm; flawless shifting. ", + " Super rigid spindle. ", + " High-strength crank arm. " + ] + }, + { + "Name": "PictureAngle", + "DataType": "nvarchar", + "Definition": "The PictureAngle column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of the angle at which a product picture is taken. The values in this column describe the perspective or viewpoint from which the product image is captured, such as 'front'. This helps users understand the visual representation of the product in the catalog.", + "AllowedValues": null, + "SampleValues": [ + "front" + ] + }, + { + "Name": "PictureSize", + "DataType": "nvarchar", + "Definition": "The PictureSize column in the SalesLT.vProductModelCatalogDescription entity contains information about the size classification of pictures used in the catalog descriptions of product models. Based on the sample value provided, the sizes are described using general descriptive terms. This column helps to categorize and filter products based on the picture size used in their catalog entries.", + "AllowedValues": null, + "SampleValues": [ + "small" + ] + }, + { + "Name": "ProductPhotoID", + "DataType": "nvarchar", + "Definition": "The ProductPhotoID column in the SalesLT.vProductModelCatalogDescription entity contains unique numeric identifiers for the photos associated with products in the catalog. Each value in this column is a distinct integer that corresponds to a specific product photo, indicating which image is linked to a particular product model. This column helps in associating product models with their respective images within the catalog.", + "AllowedValues": null, + "SampleValues": [ + "87", + "126", + "118", + "111", + "1" + ] + }, + { + "Name": "Material", + "DataType": "nvarchar", + "Definition": "The Material column in the SalesLT.vProductModelCatalogDescription entity contains the type of material used in the product models. The values in this column are descriptive names of materials, which can include various types of metals, alloys, and other substances. The sample values suggest that common materials include different forms of aluminum and aluminum alloys. The data is presented in a plain text format with no special codes or abbreviations.", + "AllowedValues": null, + "SampleValues": [ + "Aluminum Alloy", + "Aluminum", + "Almuminum Alloy" + ] + }, + { + "Name": "Color", + "DataType": "nvarchar", + "Definition": "The Color column in the SalesLT.vProductModelCatalogDescription entity contains descriptive sentences about the color availability of the products. The values generally indicate the range or exceptions in color availability, such as stating if the product is available in most colors, all colors, or specific exclusions. The descriptions often follow a common format, starting with \"Available in\" followed by details about the color options. This column helps in providing a textual representation of the color options available for each product model.", + "AllowedValues": null, + "SampleValues": [ + "Available in most colors.", + "Available in most colors", + "Available in all colors.", + "Available in all colors except metallic." + ] + }, + { + "Name": "ProductLine", + "DataType": "nvarchar", + "Definition": "The ProductLine column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of different categories of bikes. The values in this column represent various types of bikes, which can include classifications such as Touring bike, Road bike, and Mountain bike. The column helps categorize products within the catalog for better organization and ease of reference.", + "AllowedValues": null, + "SampleValues": [ + "Touring bike", + "Road bike", + "Mountain bike" + ] + }, + { + "Name": "Style", + "DataType": "nvarchar", + "Definition": "The Style column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of the targeted gender for products. The values in this column indicate whether a product is meant for men, women, or for both genders (unisex). The data helps in categorizing products based on the intended user demographic for marketing and sales purposes.", + "AllowedValues": null, + "SampleValues": [ + "Unisex", + "Men's" + ] + }, + { + "Name": "RiderExperience", + "DataType": "nvarchar", + "Definition": "The RiderExperience column in the SalesLT.vProductModelCatalogDescription entity contains descriptions of the skill levels that a product is suitable for. The values follow a pattern indicating a range of rider experience levels, such as Novice, Intermediate, Advanced, and Professional. These ranges help indicate the suitability of the product for riders with different levels of expertise and ability.", + "AllowedValues": null, + "SampleValues": [ + "Novice to Intermediate riders", + "Novice to Advanced riders", + "Intermediate to Professional riders", + "Intermediate to Advanced riders", + "Advanced to Professional riders" + ] + }, + { + "Name": "rowguid", + "DataType": "uniqueidentifier", + "Definition": "The rowguid column in the SalesLT.vProductModelCatalogDescription entity contains unique identifier values in the form of globally unique identifiers (GUIDs). Each value is a 36-character string in the standard GUID format, which includes hexadecimal characters and hyphens separating specific character groups. This column is used to uniquely identify each row in the table and ensures that each entry can be reliably distinguished from others.", + "AllowedValues": null, + "SampleValues": [ + "FCA0665B-B956-489A-A5EC-6F0B4AA14D02", + "94FFB702-0CBC-4E3F-B840-C51F0D11C8F6", + "AA10D9E6-E33F-4DA8-ACE1-992FCD6BB171", + "52E7F2C1-DBFF-4518-927D-C7D46F9ED32E", + "8456BB94-B4DD-4A47-A76B-D0E54AB4285D" + ] + }, + { + "Name": "ModifiedDate", + "DataType": "datetime", + "Definition": "The ModifiedDate column in the SalesLT.vProductModelCatalogDescription entity contains the date and time when a product model catalog description was last updated. The values follow the format 'YYYY-MM-DD HH:MM:SS.ssssss', representing year, month, day, hour, minute, second, and fractional seconds. This column is used to track changes and ensure that the catalog description data is current and up-to-date. The precise timestamp allows for accurate monitoring and auditing of modifications.", + "AllowedValues": null, + "SampleValues": [ + "2006-11-20 09:56:38.273000", + "2005-06-01 00:00:00" + ] + } + ] +} \ No newline at end of file diff --git a/text_2_sql/data_dictionary/manual_samples/entities.json b/text_2_sql/data_dictionary/manual_samples/entities.json index fdd2174..e745a04 100644 --- a/text_2_sql/data_dictionary/manual_samples/entities.json +++ b/text_2_sql/data_dictionary/manual_samples/entities.json @@ -4,22 +4,22 @@ { "Definition": "A unique identifier for each sales order ticket. This ID is auto-generated and serves as the primary key for the SalesOrderTicket table.", "Name": "SalesOrderID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The date and time when the sales order was created. This is used to track when the order was initiated.", "Name": "OrderDate", - "Type": "DATETIME" + "DataType": "DATETIME" }, { "Definition": "The date by which the order is expected to be fulfilled or delivered. It helps in managing delivery timelines.", "Name": "DueDate", - "Type": "DATETIME" + "DataType": "DATETIME" }, { "Definition": "The date when the order was shipped to the customer. This is used for tracking shipping and fulfillment status.", "Name": "ShipDate", - "Type": "DATETIME" + "DataType": "DATETIME" }, { "AllowedValues": [ @@ -29,44 +29,72 @@ ], "Definition": "The current status of the order, represented as a numeric code (e.g., 1 for In Progress, 2 for Completed, 3 for Canceled).", "Name": "Status", - "Type": "TINYINT" + "DataType": "TINYINT" }, { "Definition": "The total amount due for the order, including all line items, taxes, and shipping charges.", "Name": "TotalDue", - "Type": "MONEY" + "DataType": "MONEY" }, { "Definition": "The date and time when the sales order ticket record was last modified. This is used for tracking updates and changes to the order.", "Name": "ModifiedDate", - "Type": "DATETIME" + "DataType": "DATETIME" } ], - "Description": "This table stores detailed information about sales order tickets, including the order details, customer information, order status, and timestamps. It is used to manage and track sales orders throughout the order lifecycle, from creation to fulfillment.", + "Definition": "This table stores detailed information about sales order tickets, including the order details, customer information, order status, and timestamps. It is used to manage and track sales orders throughout the order lifecycle, from creation to fulfillment.", "Entity": "SalesOrderDetail", - "EntityName": "Sales Order Detail" + "EntityName": "Sales Order Detail", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.Product", + "ForeignKeys": [ + { + "Column": "ProductID", + "ForeignColumn": "ProductID" + } + ] + }, + { + "ForeignEntity": "SalesLT.SalesOrderHeader", + "ForeignKeys": [ + { + "Column": "SalesOrderID", + "ForeignColumn": "SalesOrderID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.SalesOrderDetail -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ] }, { "Columns": [ { "Definition": "A unique identifier for each sales order. This ID is auto-generated and serves as the primary key for the SalesOrderHeader table.", "Name": "SalesOrderID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The date and time when the sales order was created. This field is used to track when the order was initiated.", "Name": "OrderDate", - "Type": "DATETIME" + "DataType": "DATETIME" }, { "Definition": "The date by which the order is expected to be fulfilled or delivered. It helps in managing delivery timelines.", "Name": "DueDate", - "Type": "DATETIME" + "DataType": "DATETIME" }, { "Definition": "The date when the order was shipped to the customer. This is used for tracking shipping and fulfillment status.", "Name": "ShipDate", - "Type": "DATETIME" + "DataType": "DATETIME" }, { "AllowedValues": [ @@ -76,7 +104,7 @@ ], "Definition": "The current status of the order, represented as a numeric code (e.g., 1 for In Progress, 2 for Completed, 3 for Canceled).", "Name": "Status", - "Type": "TINYINT" + "DataType": "TINYINT" }, { "AllowedValues": [ @@ -85,153 +113,237 @@ ], "Definition": "Indicates whether the order was placed online.", "Name": "OnlineOrderFlag", - "Type": "BIT" + "DataType": "BIT" }, { "Definition": "A unique order number assigned to the sales order. This is used for tracking and identification purposes.", "Name": "SalesOrderNumber", - "Type": "NVARCHAR(25)" + "DataType": "NVARCHAR(25)" }, { "Definition": "The purchase order number provided by the customer. This field links the sales order to the customer's purchase order.", "Name": "PurchaseOrderNumber", - "Type": "NVARCHAR(25)" + "DataType": "NVARCHAR(25)" }, { "Definition": "The account number of the customer placing the order. This helps link the order to the customer's account.", "Name": "AccountNumber", - "Type": "NVARCHAR(15)" + "DataType": "NVARCHAR(15)" }, { "Definition": "A foreign key that links to the Customer table, representing the customer who placed the order.", "Name": "CustomerID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "A foreign key that links to the Address table, representing the shipping address for the order.", "Name": "ShipToAddressID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "A foreign key that links to the Address table, representing the billing address for the order.", "Name": "BillToAddressID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The shipping method used for the order (e.g., UPS, FedEx). This field helps track shipping preferences.", "Name": "ShipMethod", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The total cost of the order before taxes and shipping charges. This field is used to calculate the final total. The currency is pound sterling (GBP).", "Name": "SubTotal", - "Type": "MONEY" + "DataType": "MONEY" }, { "Definition": "The tax amount applied to the order. This is calculated based on the order subtotal and applicable tax rates. The currency is pound sterling (GBP).", "Name": "TaxAmt", - "Type": "MONEY" + "DataType": "MONEY" }, { "Definition": "The shipping charge applied to the order. This field represents the cost of shipping the order to the customer. The currency is pound sterling (GBP).", "Name": "Freight", - "Type": "MONEY" + "DataType": "MONEY" }, { "Definition": "The total amount due for the order, including all line items, taxes, and shipping charges. The currency is pound sterling (GBP).", "Name": "TotalDue", - "Type": "MONEY" + "DataType": "MONEY" }, { "Definition": "Any additional comments or notes related to the sales order. This field can include special instructions or remarks.", "Name": "Comment", - "Type": "NVARCHAR(255)" + "DataType": "NVARCHAR(255)" }, { "Definition": "The date and time when the sales order header record was last modified. This is used for tracking updates and changes to the order.", "Name": "ModifiedDate", - "Type": "DATETIME" + "DataType": "DATETIME" } ], - "Description": "This table contains high-level information about sales orders, including order dates, customer details, shipping information, and order status. It is used to manage and track sales orders from initiation to fulfillment.", + "Definition": "This table contains high-level information about sales orders, including order dates, customer details, shipping information, and order status. It is used to manage and track sales orders from initiation to fulfillment.", "Entity": "SalesOrderHeader", - "EntityName": "Sales Order Header" + "EntityName": "Sales Order Header", + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.SalesOrderDetail", + "ForeignKeys": [ + { + "Column": "SalesOrderID", + "ForeignColumn": "SalesOrderID" + }, + ] + }, + { + "ForeignEntity": "SalesLT.Address", + "ForeignKeys": [ + { + "Column": "BillToAddressID", + "ForeignColumn": "AddressID" + }, + { + "Column": "ShipToAddressID", + "ForeignColumn": "AddressID" + } + ] + }, + { + "ForeignEntity": "SalesLT.Customer", + "ForeignKeys": [ + { + "Column": "CustomerID", + "ForeignColumn": "CustomerID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.SalesOrderHeader -> SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer", + "SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress -> SalesLT.Address" + ] }, { "Columns": [ { "Definition": "A unique identifier for each address. This ID is auto-generated and serves as the primary key for the Address table.", "Name": "AddressID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The city in which the address is located. This is used to specify the city for the address.", "Name": "City", - "Type": "NVARCHAR(30)" + "DataType": "NVARCHAR(30)" }, { "Definition": "The state or province in which the address is located. This is used to specify the state or province for the address.", "Name": "StateProvince", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The country or region in which the address is located. This is used to specify the country or region for the address.", "Name": "CountryRegion", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The postal code associated with the address. This is used to specify the postal code for the address, which helps in geographical sorting and shipping.", "Name": "PostalCode", - "Type": "NVARCHAR(15)" + "DataType": "NVARCHAR(15)" }, { "Definition": "The date and time when the address record was last modified. This is used for tracking updates and changes to the address information.", "Name": "ModifiedDate", - "Type": "DATETIME" + "DataType": "DATETIME" } ], - "Description": "This table stores address information for customers, including street addresses, city, state, postal code, and country/region. It is used to maintain contact and shipping information for orders, as well as to manage customer locations.", + "Definition": "This table stores address information for customers, including street addresses, city, state, postal code, and country/region. It is used to maintain contact and shipping information for orders, as well as to manage customer locations.", "Entity": "Address", - "EntityName": "Address" + "EntityName": "Address", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [ + { + "ForeignEntity": "SalesLT.CustomerAddress", + "ForeignKeys": [ + { + "Column": "AddressID", + "ForeignColumn": "AddressID" + } + ] + }, + { + "ForeignEntity": "SalesLT.SalesOrderHeader", + "ForeignKeys": [ + { + "Column": "AddressID", + "ForeignColumn": "BillToAddressID" + }, + { + "Column": "AddressID", + "ForeignColumn": "BillToAddressID" + }, + { + "Column": "AddressID", + "ForeignColumn": "BillToAddressID" + }, + { + "Column": "AddressID", + "ForeignColumn": "ShipToAddressID" + } + ] + } + ], + "CompleteEntityRelationshipsGraph": [ + "SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.Address -> SalesLT.CustomerAddress -> SalesLT.Customer -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductCategory", + "SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.SalesOrderDetail -> SalesLT.Product -> SalesLT.ProductModel -> SalesLT.ProductModelProductDescription -> SalesLT.ProductDescription", + "SalesLT.Address -> SalesLT.SalesOrderHeader -> SalesLT.Customer -> SalesLT.CustomerAddress" + ] }, { "Columns": [ { "Definition": "A unique identifier for each product category. This ID is used to reference specific categories.", "Name": "ProductCategoryID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The name of the parent product category. This represents the top-level category under which subcategories are grouped.", "Name": "ParentProductCategoryName", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The name of the product category. This can refer to either a top-level category or a subcategory, depending on the context.", "Name": "ProductCategoryName", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" } ], - "Description": "This view provides a comprehensive list of all product categories and their corresponding subcategories in the SalesLT schema of the AdventureWorksLT database. It is used to understand the hierarchical structure of product categories, facilitating product organization and categorization.", + "Definition": "This view provides a comprehensive list of all product categories and their corresponding subcategories in the SalesLT schema of the AdventureWorksLT database. It is used to understand the hierarchical structure of product categories, facilitating product organization and categorization.", "Entity": "vGetAllCategories", - "EntityName": "Get All Categories" + "EntityName": "Get All Categories", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [], + "CompleteEntityRelationshipsGraph": [] }, { "Columns": [ { "Definition": "A unique identifier for each product. This ID is used to distinguish individual products.", "Name": "ProductID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The name of the product. This provides a brief and identifiable name for each product.", "Name": "Name", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The model name associated with the product. This indicates the specific model type or version of the product.", "Name": "ProductModel", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The culture or language code for the product description. This is used to localize the product description, such as 'en' for English or 'fr' for French.", @@ -242,143 +354,151 @@ "es", "de" ], - "Type": "NVARCHAR(6)" + "DataType": "NVARCHAR(6)" }, { "Definition": "A detailed description of the product. This text provides additional information about the product, which can vary based on the culture or language.", - "Name": "Description", - "Type": "NVARCHAR(400)" + "Name": "Definition", + "DataType": "NVARCHAR(400)" } ], - "Description": "This view provides detailed information about products, including their names, associated product models, descriptions, and the specific culture or language of the description. It is useful for understanding product details and translating product descriptions for different cultures.", + "Definition": "This view provides detailed information about products, including their names, associated product models, descriptions, and the specific culture or language of the description. It is useful for understanding product details and translating product descriptions for different cultures.", "Entity": "vProductAndDescription", - "EntityName": "Product and Description" + "EntityName": "Product and Description", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [], + "CompleteEntityRelationshipsGraph": [] }, { "Columns": [ { "Definition": "A unique identifier for each product model. This ID is used to distinguish different product models.", "Name": "ProductModelID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The name of the product model, providing a recognizable title for each model.", "Name": "Name", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "A brief summary of the product model, highlighting key features and characteristics.", "Name": "Summary", - "Type": "NVARCHAR(MAX)" + "DataType": "NVARCHAR(MAX)" }, { "Definition": "The name of the manufacturer of the product model.", "Name": "Manufacturer", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "Copyright information related to the product model, indicating the legal ownership of the product design and content.", "Name": "Copyright", - "Type": "NVARCHAR(30)" + "DataType": "NVARCHAR(30)" }, { "Definition": "The URL for the product model, providing a link to more information or to purchase the product.", "Name": "ProductURL", - "Type": "NVARCHAR(256)" + "DataType": "NVARCHAR(256)" }, { "Definition": "The duration of the warranty period for the product model, specifying how long the warranty is valid.", "Name": "WarrantyPeriod", - "Type": "NVARCHAR(30)" + "DataType": "NVARCHAR(30)" }, { "Definition": "A description of the warranty provided for the product model, detailing what is covered under the warranty.", "Name": "WarrantyDescription", - "Type": "NVARCHAR(255)" + "DataType": "NVARCHAR(255)" }, { "Definition": "The number of years the warranty is valid for the product model.", "Name": "NoOfYears", - "Type": "INT" + "DataType": "INT" }, { "Definition": "A description of the maintenance requirements and recommendations for the product model.", "Name": "MaintenanceDescription", - "Type": "NVARCHAR(MAX)" + "DataType": "NVARCHAR(MAX)" }, { "Definition": "Details about the type of wheels used in the product model.", "Name": "Wheel", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "Information about the saddle of the product model, such as material and design.", "Name": "Saddle", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "Details regarding the pedal design and specifications of the product model.", "Name": "Pedal", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "Description of the bike frame used in the product model, including material and type.", "Name": "BikeFrame", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "Information about the crankset of the product model, specifying its design and features.", "Name": "Crankset", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The angle at which the product model is photographed, providing a visual perspective of the product.", "Name": "PictureAngle", - "Type": "NVARCHAR(20)" + "DataType": "NVARCHAR(20)" }, { "Definition": "The size of the product model's picture, specifying dimensions or resolution.", "Name": "PictureSize", - "Type": "NVARCHAR(20)" + "DataType": "NVARCHAR(20)" }, { "Definition": "An identifier linking to the product photo, which provides a visual representation of the product model.", "Name": "ProductPhotoID", - "Type": "INT" + "DataType": "INT" }, { "Definition": "The material used in the construction of the product model, indicating durability and quality.", "Name": "Material", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The color of the product model, providing information about the appearance of the product.", "Name": "Color", - "Type": "NVARCHAR(15)" + "DataType": "NVARCHAR(15)" }, { "Definition": "A code representing the product line to which the model belongs, categorizing the product within a broader product range.", "Name": "ProductLine", - "Type": "NVARCHAR(2)" + "DataType": "NVARCHAR(2)" }, { "Definition": "The style of the product model, indicating design and aesthetic aspects.", "Name": "Style", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "A description of the target rider's experience level for which the product model is designed, such as beginner, intermediate, or expert.", "Name": "RiderExperience", - "Type": "NVARCHAR(50)" + "DataType": "NVARCHAR(50)" }, { "Definition": "The date and time when the product model information was last modified, indicating the currency of the data.", "Name": "ModifiedDate", - "Type": "DATETIME" + "DataType": "DATETIME" } ], - "Description": "This view provides detailed catalog information about product models, including descriptions, manufacturing details, warranty information, and specifications related to product design and features. It is useful for generating comprehensive product catalogs and providing detailed product information to customers.", + "Definition": "This view provides detailed catalog information about product models, including descriptions, manufacturing details, warranty information, and specifications related to product design and features. It is useful for generating comprehensive product catalogs and providing detailed product information to customers.", "Entity": "vProductModelCatalogDescription", - "EntityName": "Product Model Catalog Description" + "EntityName": "Product Model Catalog Description", + "Database": "AdventureWorksLT", + "Warehouse": null, + "EntityRelationships": [], + "CompleteEntityRelationshipsGraph": [] } -] +] \ No newline at end of file diff --git a/text_2_sql/data_dictionary/requirements.txt b/text_2_sql/data_dictionary/requirements.txt index 92621b3..becad18 100644 --- a/text_2_sql/data_dictionary/requirements.txt +++ b/text_2_sql/data_dictionary/requirements.txt @@ -3,3 +3,4 @@ azure-identity python-dotenv pydantic openai +networkx diff --git a/text_2_sql/data_dictionary/sql_sever_data_dictionary_creator.py b/text_2_sql/data_dictionary/sql_sever_data_dictionary_creator.py index 4b71105..ed7a9c8 100644 --- a/text_2_sql/data_dictionary/sql_sever_data_dictionary_creator.py +++ b/text_2_sql/data_dictionary/sql_sever_data_dictionary_creator.py @@ -2,6 +2,7 @@ # Licensed under the MIT License. from data_dictionary_creator import DataDictionaryCreator, EntityItem import asyncio +import os class SqlServerDataDictionaryCreator(DataDictionaryCreator): @@ -24,7 +25,8 @@ def __init__( excluded_entities.extend( ["dbo.BuildVersion", "dbo.ErrorLog", "sys.database_firewall_rules"] ) - return super().__init__(entities, excluded_entities, single_file) + super().__init__(entities, excluded_entities, single_file) + self.database = os.environ["Text2Sql__DatabaseName"] """A class to extract data dictionary information from a SQL Server database.""" @@ -34,7 +36,7 @@ def extract_table_entities_sql_query(self) -> str: return """SELECT t.TABLE_NAME AS Entity, t.TABLE_SCHEMA AS EntitySchema, - CAST(ep.value AS NVARCHAR(500)) AS Description + CAST(ep.value AS NVARCHAR(500)) AS Definition FROM INFORMATION_SCHEMA.TABLES t LEFT JOIN @@ -52,7 +54,7 @@ def extract_view_entities_sql_query(self) -> str: return """SELECT v.TABLE_NAME AS Entity, v.TABLE_SCHEMA AS EntitySchema, - CAST(ep.value AS NVARCHAR(500)) AS Description + CAST(ep.value AS NVARCHAR(500)) AS Definition FROM INFORMATION_SCHEMA.VIEWS v LEFT JOIN @@ -66,7 +68,7 @@ def extract_columns_sql_query(self, entity: EntityItem) -> str: """A property to extract column information from a SQL Server database.""" return f"""SELECT c.COLUMN_NAME AS Name, - c.DATA_TYPE AS Type, + c.DATA_TYPE AS DataType, CAST(ep.value AS NVARCHAR(500)) AS Definition FROM INFORMATION_SCHEMA.COLUMNS c @@ -80,6 +82,36 @@ def extract_columns_sql_query(self, entity: EntityItem) -> str: c.TABLE_SCHEMA = '{entity.entity_schema}' AND c.TABLE_NAME = '{entity.name}';""" + @property + def extract_entity_relationships_sql_query(self) -> str: + """A property to extract entity relationships from a SQL Server database.""" + return """SELECT + fk_schema.name AS EntitySchema, + fk_tab.name AS Entity, + pk_schema.name AS ForeignEntitySchema, + pk_tab.name AS ForeignEntity, + fk_col.name AS [Column], + pk_col.name AS ForeignColumn + FROM + sys.foreign_keys AS fk + INNER JOIN + sys.foreign_key_columns AS fkc ON fk.object_id = fkc.constraint_object_id + INNER JOIN + sys.tables AS fk_tab ON fk_tab.object_id = fk.parent_object_id + INNER JOIN + sys.schemas AS fk_schema ON fk_tab.schema_id = fk_schema.schema_id + INNER JOIN + sys.tables AS pk_tab ON pk_tab.object_id = fk.referenced_object_id + INNER JOIN + sys.schemas AS pk_schema ON pk_tab.schema_id = pk_schema.schema_id + INNER JOIN + sys.columns AS fk_col ON fkc.parent_object_id = fk_col.object_id AND fkc.parent_column_id = fk_col.column_id + INNER JOIN + sys.columns AS pk_col ON fkc.referenced_object_id = pk_col.object_id AND fkc.referenced_column_id = pk_col.column_id + ORDER BY + EntitySchema, Entity, ForeignEntitySchema, ForeignEntity; + """ + if __name__ == "__main__": data_dictionary_creator = SqlServerDataDictionaryCreator() diff --git a/text_2_sql/semantic_kernel/plugins/vector_based_sql_plugin/vector_based_sql_plugin.py b/text_2_sql/semantic_kernel/plugins/vector_based_sql_plugin/vector_based_sql_plugin.py index 6544137..53bfa31 100644 --- a/text_2_sql/semantic_kernel/plugins/vector_based_sql_plugin/vector_based_sql_plugin.py +++ b/text_2_sql/semantic_kernel/plugins/vector_based_sql_plugin/vector_based_sql_plugin.py @@ -143,7 +143,7 @@ async def fetch_queries_from_cache(self, question: str) -> str: cached_schemas = await run_ai_search_query( question, ["QuestionEmbedding"], - ["Question", "Query", "Schemas"], + ["Question", "SqlQueryDecomposition", "Schemas"], os.environ["AIService__AzureSearchOptions__Text2SqlQueryCache__Index"], os.environ[ "AIService__AzureSearchOptions__Text2SqlQueryCache__SemanticConfig" @@ -172,17 +172,27 @@ async def fetch_queries_from_cache(self, question: str) -> str: if cached_schemas[0]["@search.reranker_score"] > 2.75: logging.info("Score is greater than 3") - sql_query = cached_schemas[0]["Query"] - schemas = cached_schemas[0]["Schemas"] + sql_queries = cached_schemas[0]["SqlQueryDecomposition"] + query_result_store = {} - logging.info("SQL Query: %s", sql_query) + query_tasks = [] - # Run the SQL query - sql_result = await self.query_execution(sql_query) - logging.info("SQL Query Result: %s", sql_result) + for sql_query in sql_queries: + logging.info("SQL Query: %s", sql_query) - pre_fetched_results_string = f"""[BEGIN PRE-FETCHED RESULTS FOR SQL QUERY = '{sql_query}']\n{ - json.dumps(sql_result, default=str)}\nSchema={json.dumps(schemas, default=str)}\n[END PRE-FETCHED RESULTS FOR SQL QUERY]\n""" + # Run the SQL query + query_tasks.append(self.query_execution(sql_query["SqlQuery"])) + + sql_results = await asyncio.gather(*query_tasks) + + for sql_query, sql_result in zip(sql_queries, sql_results): + query_result_store[sql_query["SqlQuery"]] = { + "result": sql_result, + "schemas": sql_queries["schemas"], + } + + pre_fetched_results_string = f"""[BEGIN PRE-FETCHED RESULTS FOR CACHED SQL QUERIES]\n{ + json.dumps(query_result_store, default=str)}\n[END PRE-FETCHED RESULTS FOR CACHED SQL QUERIES]\n""" return pre_fetched_results_string @@ -330,8 +340,10 @@ async def run_sql_query( entry = { "Question": self.question, - "Query": sql_query, - "Schemas": cleaned_schemas, + "SqlQueryDecomposition": { + "SqlQuery": sql_query, + "Schemas": cleaned_schemas, + }, } except Exception as e: logging.error("Error: %s", e)