def execute(self, model, manifest):
context = dbt.context.runtime.generate(model, self.config, manifest)
materialization_macro = manifest.get_materialization_macro(
self.config.project_name, model.get_materialization(),
self.adapter.type())
if materialization_macro is None:
missing_materialization(model, self.adapter.type())
if 'config' not in context:
raise InternalException(
'Invalid materialization context generated, missing config: {}'
.format(context))
context_config = context['config']
hook_ctx = self.adapter.pre_model_hook(context_config)
try:
result = materialization_macro.generator(context)()
finally:
self.adapter.post_model_hook(context_config, hook_ctx)
for relation in self._materialization_relations(result, model):
self.adapter.cache_added(relation.incorporate(dbt_created=True))
return self._build_run_model_result(model, context)
def execute(self, model, manifest):
context = dbt.context.runtime.generate(model, self.config, manifest)
materialization_macro = manifest.get_materialization_macro(
model.get_materialization(), self.adapter.type())
if materialization_macro is None:
missing_materialization(model, self.adapter.type())
materialization_macro.generator(context)()
# we must have built a new model, add it to the cache
relation = self.adapter.Relation.create_from_node(self.config, model)
self.adapter.cache_new_relation(relation)
result = context['load_result']('main')
return RunModelResult(model, status=result.status)
def execute(self, model, manifest):
context = dbt.context.runtime.generate(
model, self.config, manifest)
materialization_macro = manifest.get_materialization_macro(
model.get_materialization(),
self.adapter.type())
if materialization_macro is None:
missing_materialization(model, self.adapter.type())
materialization_macro.generator(context)()
# we must have built a new model, add it to the cache
relation = self.adapter.Relation.create_from_node(self.config, model)
self.adapter.cache_new_relation(relation)
result = context['load_result']('main')
return RunModelResult(model, status=result.status)
def execute_test(self, test: Union[CompiledDataTestNode,
CompiledSchemaTestNode],
manifest: Manifest) -> int:
context = generate_runtime_model(test, self.config, manifest)
materialization_macro = manifest.find_materialization_macro_by_name(
self.config.project_name, test.get_materialization(),
self.adapter.type())
if materialization_macro is None:
missing_materialization(test, self.adapter.type())
if 'config' not in context:
raise InternalException(
'Invalid materialization context generated, missing config: {}'
.format(context))
# generate materialization macro
# simple `select(*)` of the compiled test node
macro_func = MacroGenerator(materialization_macro, context)
# execute materialization macro
macro_func()
# load results from context
# could eventually be returned directly by materialization
result = context['load_result']('main')
table = result['table']
num_rows = len(table.rows)
if num_rows != 1:
num_cols = len(table.columns)
# since we just wrapped our query in `select count(*)`, we are in
# big trouble!
raise InternalException(
f"dbt internally failed to execute {test.unique_id}: "
f"Returned {num_rows} rows and {num_cols} cols, but expected "
f"1 row and 1 column")
return int(table[0][0])