Rip out dry run

dbt/compilation.py

@@ -63,12 +63,6 @@ def model_sources(self, this_project, own_project=None):
  own_project=own_project
  ).get_models(paths, self.create_template)
 
- elif self.create_template.label == 'test':
- return Source(
- this_project,
- own_project=own_project
- ).get_test_models(paths, self.create_template)
-
  elif self.create_template.label == 'archive':
  return []
  else:

dbt/compiled_model.py

@@ -1,6 +1,7 @@
 import hashlib
 import jinja2
 from dbt.utils import compiler_error, to_unicode
+from dbt.adapters.factory import get_adapter
 
 
 class CompiledModel(object):
@@ -157,7 +158,7 @@ def __repr__(self):
 def make_compiled_model(fqn, data):
  run_type = data['dbt_run_type']
 
- if run_type in ['run', 'dry-run']:
+ if run_type == 'run':
  return CompiledModel(fqn, data)
  elif run_type == 'test':
  return CompiledTest(fqn, data)

dbt/main.py

@@ -235,11 +235,6 @@ def parse_args(args):
  sub.set_defaults(cls=clean_task.CleanTask, which='clean')
 
  sub = subs.add_parser('compile', parents=[base_subparser])
- sub.add_argument(
- '--dry',
- action='store_true',
- help="Compile 'dry run' models"
- )
  sub.add_argument(
  '--non-destructive',
  action='store_true',
@@ -277,7 +272,6 @@ def parse_args(args):
  sub.set_defaults(cls=archive_task.ArchiveTask, which='archive')
 
  sub = subs.add_parser('run', parents=[base_subparser])
- sub.add_argument('--dry', action='store_true', help="'dry run' models")
  sub.add_argument(
  '--models',
  required=False,

dbt/model.py

@@ -2,7 +2,7 @@
 import yaml
 import jinja2
 import re
-from dbt.templates import BaseCreateTemplate, DryCreateTemplate
+from dbt.templates import BaseCreateTemplate
 from dbt.utils import split_path
 import dbt.schema_tester
 import dbt.project
@@ -502,48 +502,6 @@ def __repr__(self):
  return "<Analysis {}: {}>".format(self.name, self.filepath)
 
 
-class TestModel(Model):
- dbt_run_type = 'dry-run'
-
- def __init__(
- self,
- project,
- target_dir,
- rel_filepath,
- own_project,
- create_template
- ):
- return super(TestModel, self).__init__(
- project, target_dir, rel_filepath, own_project, create_template
- )
-
- def build_path(self):
- build_dir = self.create_template.label
- filename = "{}.sql".format(self.name)
- path_parts = [build_dir] + self.fqn[:-1] + [filename]
- return os.path.join(*path_parts)
-
- @property
- def fqn(self):
- """fully-qualified name for model. Includes all subdirs below 'models'
- path and the filename"""
- parts = split_path(self.filepath)
- name, _ = os.path.splitext(parts[-1])
- test_name = DryCreateTemplate.model_name(name)
- return [self.own_project['name']] + parts[1:-1] + [test_name]
-
- @property
- def original_fqn(self):
- parts = split_path(self.filepath)
- name, _ = os.path.splitext(parts[-1])
- return [self.project['name']] + parts[1:-1] + [name]
-
- def __repr__(self):
- return "<TestModel {}.{}: {}>".format(
- self.project['name'], self.name, self.filepath
- )
-
-
 class SchemaTest(DBTSource):
  test_type = "base"
  dbt_run_type = 'test'

dbt/runner.py

@@ -205,51 +205,6 @@ def post_run_all(self, models, results, context):
  self.__run_hooks(hooks, context, 'on-run-end hooks')
 
 
-class DryRunner(ModelRunner):
- run_type = 'dry-run'
-
- def pre_run_msg(self, model):
- output = ("DRY-RUN model {schema}.{model_name} "
- .format(
- schema=self.adapter.get_default_schema(self.profile),
- model_name=model.name))
- return output
-
- def post_run_msg(self, result):
- model = result.model
- output = ("DONE model {schema}.{model_name} "
- .format(
- schema=self.adapter.get_default_schema(self.profile),
- model_name=model.name))
- return output
-
- def pre_run_all_msg(self, models):
- return "Dry-running {} models".format(len(models))
-
- def post_run_all_msg(self, results):
- return ("{} Finished dry-running {} models"
- .format(get_timestamp(), len(results)))
-
- def post_run_all(self, models, results, context):
- profile = self.project.run_environment()
- adapter = get_adapter(profile)
-
- count_dropped = 0
- for result in results:
- if result.errored or result.skipped:
- continue
- model = result.model
- schema_name = self.adapter.get_default_schema(self.profile)
-
- relation_type = ('table' if model.materialization == 'incremental'
- else 'view')
- adapter.drop(profile, model.name, relation_type, model.name)
- count_dropped += 1
-
- adapter.commit(profile)
- logger.info("Dropped {} dry-run models".format(count_dropped))
-
-
 class TestRunner(ModelRunner):
  run_type = 'test'
 
@@ -735,10 +690,6 @@ def run(self, limit_to=None):
  runner = ModelRunner(self.project)
  return self.run_from_graph(runner, limit_to)
 
- def dry_run(self, limit_to=None):
- runner = DryRunner(self.project)
- return self.run_from_graph(runner, limit_to)
-
  def run_archive(self):
  runner = ArchiveRunner(self.project)
  return self.run_from_graph(runner, None)

dbt/source.py

@@ -1,6 +1,6 @@
 import os.path
 import fnmatch
-from dbt.model import Model, Analysis, TestModel, SchemaFile, Csv, Macro, \
+from dbt.model import Model, Analysis, SchemaFile, Csv, Macro, \
  ArchiveModel, DataTest
 
 import dbt.clients.system
@@ -42,17 +42,6 @@ def get_models(self, model_dirs, create_template):
  file_matches,
  [create_template])
 
- def get_test_models(self, model_dirs, create_template):
- file_matches = dbt.clients.system.find_matching(
- self.own_project_root,
- model_dirs,
- "[!.#~]*.sql")
-
- return self.build_models_from_file_matches(
- TestModel,
- file_matches,
- [create_template])
-
  def get_analyses(self, analysis_dirs):
  file_matches = dbt.clients.system.find_matching(
  self.own_project_root,

dbt/task/compile.py

@@ -1,5 +1,5 @@
 from dbt.compilation import Compiler, CompilableEntities
-from dbt.templates import BaseCreateTemplate, DryCreateTemplate
+from dbt.templates import BaseCreateTemplate
 from dbt.logger import GLOBAL_LOGGER as logger
 
 
@@ -9,12 +9,7 @@ def __init__(self, args, project):
  self.project = project
 
  def run(self):
- if self.args.dry:
- create_template = DryCreateTemplate
- else:
- create_template = BaseCreateTemplate
-
- compiler = Compiler(self.project, create_template, self.args)
+ compiler = Compiler(self.project, BaseCreateTemplate, self.args)
  compiler.initialize()
  results = compiler.compile(limit_to=CompilableEntities)
 

dbt/task/run.py

@@ -1,11 +1,9 @@
 from __future__ import print_function
 
-import os
-
 from dbt.compilation import Compiler, CompilableEntities
 from dbt.logger import GLOBAL_LOGGER as logger
 from dbt.runner import RunManager
-from dbt.templates import DryCreateTemplate, BaseCreateTemplate
+from dbt.templates import BaseCreateTemplate
 
 THREAD_LIMIT = 9
 
@@ -16,9 +14,7 @@ def __init__(self, args, project):
  self.project = project
 
  def compile(self):
- create_template = DryCreateTemplate if self.args.dry \
- else BaseCreateTemplate
- compiler = Compiler(self.project, create_template, self.args)
+ compiler = Compiler(self.project, BaseCreateTemplate, self.args)
  compiler.initialize()
  results = compiler.compile(limit_to=['models'])
 
@@ -27,7 +23,7 @@ def compile(self):
  ])
  logger.info("Compiled {}".format(stat_line))
 
- return create_template.label
+ return BaseCreateTemplate.label
 
  def run(self):
  graph_type = self.compile()
@@ -36,10 +32,7 @@ def run(self):
  self.project, self.project['target-path'], graph_type, self.args
  )
 
- if self.args.dry:
- results = runner.dry_run(self.args.models)
- else:
- results = runner.run(self.args.models)
+ results = runner.run(self.args.models)
 
  total = len(results)
  passed = len([r for r in results if not r.errored and not r.skipped])

dbt/task/test.py

@@ -1,12 +1,7 @@
-import os
-import psycopg2
-import sys
-import yaml
 
 from dbt.compilation import Compiler, CompilableEntities
-from dbt.templates import DryCreateTemplate, BaseCreateTemplate
+from dbt.templates import BaseCreateTemplate
 from dbt.runner import RunManager
-from dbt.schema_tester import SchemaTester
 from dbt.logger import GLOBAL_LOGGER as logger
 
 

dbt/templates.py

@@ -118,56 +118,6 @@ def wrap(self, opts):
  return self.add_extras(opts, sql)
 
 
-class DryCreateTemplate(object):
- base_template = u"""
-create view "{schema}"."{identifier}" as (
- SELECT * FROM (
- {query}
- ) as tmp LIMIT 0
-);"""
-
-
- incremental_template = u"""
-create table "{schema}"."{identifier}" {dist_qualifier} {sort_qualifier} as (
- select * from (
- {query}
- ) s limit 0
-);
- """
-
- incremental_delete_template = u"""
-delete from "{schema}"."{identifier}" where ({unique_key}) in (
- select ({unique_key}) from "{identifier}__dbt_incremental_tmp"
-);
-"""
-
- label = "test"
-
- @classmethod
- def model_name(cls, base_name):
- return 'test_{}'.format(base_name)
-
- def wrap(self, opts):
- sql = ""
- if opts['materialization'] in ('table', 'view'):
- sql = self.base_template.format(**opts)
- elif opts['materialization'] == 'incremental':
- if opts.get('unique_key') is not None:
- delete_sql = self.incremental_delete_template.format(**opts)
- else:
- delete_sql = "-- no unique key provided... skipping delete"
-
- opts['incremental_delete_statement'] = delete_sql
- sql = self.incremental_template.format(**opts)
-
- elif opts['materialization'] == 'ephemeral':
- sql = opts['query']
- else:
- raise RuntimeError("Invalid materialization parameter ({})".format(opts['materialization']))
-
- return "{}\n\n{}".format(opts['prologue'], sql)
-
-
 SCDArchiveTemplate = u"""
 
  with "current_data" as (

dbt/tracking.py

@@ -69,10 +69,7 @@ def get_options(args):
 
 
 def get_run_type(args):
- if 'dry' in args and args.dry is True:
- return 'dry'
- else:
- return 'regular'
+ return 'regular'
 
 
 def get_invocation_context(invocation_id, user, project, args):