def parse(self, parser):
node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
materialization_name = \
parser.parse_assign_target(name_only=True).name
adapter_name = 'default'
node.args = []
node.defaults = []
while parser.stream.skip_if('comma'):
target = parser.parse_assign_target(name_only=True)
if target.name == 'default':
pass
elif target.name == 'adapter':
parser.stream.expect('assign')
value = parser.parse_expression()
adapter_name = value.value
else:
dbt.exceptions.invalid_materialization_argument(
materialization_name, target.name)
node.name = dbt.utils.get_materialization_macro_name(
materialization_name, adapter_name)
node.body = parser.parse_statements(('name:endmaterialization', ),
drop_needle=True)
return node
def parse(self, parser):
node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
materialization_name = \
parser.parse_assign_target(name_only=True).name
adapter_name = 'default'
node.args = []
node.defaults = []
while parser.stream.skip_if('comma'):
target = parser.parse_assign_target(name_only=True)
if target.name == 'default':
pass
elif target.name == 'adapter':
parser.stream.expect('assign')
value = parser.parse_expression()
adapter_name = value.value
else:
dbt.exceptions.invalid_materialization_argument(
materialization_name, target.name)
node.name = dbt.utils.get_materialization_macro_name(
materialization_name, adapter_name)
node.body = parser.parse_statements(('name:endmaterialization',),
drop_needle=True)
return node
def _parse_load(self, parser, type):
lineno = next(parser.stream).lineno
parser.stream.expect('name:as')
target = parser.parse_assign_target(name_only=True).name
body_nodes = parser.parse_statements(('name:endload', ),
drop_needle=True)
# Since Jinja 2.10, the AssignBlock node has a filter field that could
# directly be used to apply a filter. Unfortunately, this would make our
# code incompatible with earlier versions of Jinja, so we set it to None
# if it exists and add a separate FilterNode.
if 'filter' in jinja2.nodes.AssignBlock.fields:
assign_block_node = jinja2.nodes.AssignBlock(jinja2.nodes.Name(
target, 'store', lineno=lineno),
None,
body_nodes,
lineno=lineno)
else:
assign_block_node = jinja2.nodes.AssignBlock(jinja2.nodes.Name(
target, 'store', lineno=lineno),
body_nodes,
lineno=lineno)
filter_name = 'load_' + type
filter_node = jinja2.nodes.Filter(jinja2.nodes.Name(target,
'load',
lineno=lineno),
filter_name, [], [],
None,
None,
lineno=lineno)
assign_node = jinja2.nodes.Assign(jinja2.nodes.Name(target,
'store',
lineno=lineno),
filter_node,
lineno=lineno)
return [assign_block_node, assign_node]
def _parse_import(self, parser, type):
# We do not use parser.parse_import here because it is not clear whether
# that function is part of the stable API (the documentation does not
# mention that method).
lineno = next(parser.stream).lineno
import_node = jinja2.nodes.Import(lineno=lineno)
import_node.template = parser.parse_expression()
parser.stream.expect('name:as')
import_node.target = parser.parse_assign_target(name_only=True).name
if (parser.stream.current.test_any('name:with', 'name:without')
and parser.stream.look().test('name:context')):
import_node.with_context = next(parser.stream).value == 'with'
parser.stream.skip()
else:
import_node.with_context = False
# The import node will take care of loading the referenced template and
# making its contents available under the specified variable name. We
# still have to transform the variable by deserializing the JSON or YAML
# string. We do this by applying the appropriate filter on the variable
# and assigning the result back to the variable.
filter_name = 'load_' + type
filter_node = jinja2.nodes.Filter(jinja2.nodes.Name(import_node.target,
'load',
lineno=lineno),
filter_name, [], [],
None,
None,
lineno=lineno)
assign_node = jinja2.nodes.Assign(jinja2.nodes.Name(import_node.target,
'store',
lineno=lineno),
filter_node,
lineno=lineno)
return [import_node, assign_node]
def parse(self, parser):
node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
operation_name = \
parser.parse_assign_target(name_only=True).name
node.args = []
node.defaults = []
while parser.stream.skip_if('comma'):
target = parser.parse_assign_target(name_only=True)
node.name = dbt.utils.get_operation_macro_name(operation_name)
node.body = parser.parse_statements(('name:endoperation', ),
drop_needle=True)
return node
def parse(self, parser):
node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
docs_name = parser.parse_assign_target(name_only=True).name
node.args = []
node.defaults = []
node.name = dbt.utils.get_docs_macro_name(docs_name)
node.body = parser.parse_statements(('name:enddocs', ),
drop_needle=True)
return node
def parse(self, parser):
node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
test_name = parser.parse_assign_target(name_only=True).name
parser.parse_signature(node)
node.defaults = []
node.name = get_test_macro_name(test_name)
node.body = parser.parse_statements(('name:endtest', ),
drop_needle=True)
return node
def parse(self, parser):
node = jinja2.nodes.Macro(lineno=next(parser.stream).lineno)
docs_name = parser.parse_assign_target(name_only=True).name
node.args = []
node.defaults = []
node.name = dbt.utils.get_docs_macro_name(docs_name)
node.body = parser.parse_statements(('name:enddocs',),
drop_needle=True)
return node
def _parse_qblock(self, parser, lineno):
name = parser.parse_assign_target(name_only=True).name
body = parser.parse_statements(['name:endqblock'], drop_needle=True)
return nodes.If(
nodes.Compare( # test
nodes.Const(name),
[nodes.Operand('in', nodes.Name('__blocks__', 'load'))]),
body,
[], # elif_
[] # orelse
).set_lineno(lineno)
def _parse_query(self, parser, lineno):
name = parser.parse_assign_target(with_tuple=False).name
body = parser.parse_statements(['name:endquery'], drop_needle=True)
# name, params, defaults, body
return nodes.Macro(name, [nodes.Name('__blocks__', 'param')], [],
body).set_lineno(lineno)
