purview 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e7d924c2525271d6ebf479f498241505bbac3e8
-  data.tar.gz: 34f49f218bf0268b3801d715a73aa34a5c6847b0
+  metadata.gz: ba79aba1227a4d2427c31df3f0915e4ca579cc2f
+  data.tar.gz: 8c1bc2ce35e5f9d96dbfcc6460856fc5c9725c98
 SHA512:
-  metadata.gz: d4f941aeccb17386c82742f3ab4259321ca6d9da026a7a6da3ae1b202125f638153b33c19b5fcededd713287073f913f221b15560a7384403241c0f740721928
-  data.tar.gz: 8761615f2d7bfa444bf9b0f6249801a68edd96f3ed65a286c5abe9f9a6b3143004b2672fd33ab53dfeee652d565152f533c93125272779434e8f7d58f4dd0104
+  metadata.gz: f0f4f52d8dd55a5d59f73e7022c6007fcfaa4b2c66506cb3f73982ade552e3d9fdaa45a00987965056a20a646f78c0f3c9def2aade3820025a6bf782a0b5cab3
+  data.tar.gz: 43dd4c3d045d9cd242cd046768cc98d384ba8ad76706640143ebc55d581c132e774653cecdeb18a935a11ebfd1d9c98d4899372fa0618309af7a5f6a8ac9c6d5

data/.gitignore

@@ -1,5 +1,3 @@
-*.gem
-*.rbc
 /.config
 /InstalledFiles
 /coverage/
@@ -9,7 +7,11 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
+
+*.gem
+*.rbc
 tags
+tags.*
 
 ## Specific to RubyMotion:
 .dat*

data/.travis.yml

@@ -5,14 +5,8 @@ before_install:
   - sudo apt-get install -q freetds-dev
 
 rvm:
-  - 1.9.3
   - 2.0.0
-  - 2.1.0
-  - 2.1.1
-  - 2.1.2
-  - 2.1.3
-  - 2.1.4
-  - 2.1.5
-  - 2.2.0
-  - jruby-19mode
-  - rbx-2
+  - 2.1.9
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0

data/Gemfile

@@ -2,13 +2,15 @@ source 'https://rubygems.org'
 
 group :development do
   if defined?(JRUBY_VERSION)
-    gem 'jdbc-jtds', '~> 1.3'
-    gem 'jdbc-mysql', '~> 5.1'
-    gem 'jdbc-postgres', '~> 9.4'
+    gem 'jdbc-jtds', '~> 1.0'
+    gem 'jdbc-mysql', '~> 5.0'
+    gem 'jdbc-postgres', '~> 9.0'
+    gem 'jdbc-sqlite3', '~> 3.0'
   else
-    gem 'mysql2', '~> 0.3'
-    gem 'pg', '~> 0.18'
-    gem 'tiny_tds', '~> 0.6'
+    gem 'mysql2', '~> 0.4'
+    gem 'pg', '~> 0.20'
+    gem 'sqlite3', '~> 1.0'
+    gem 'tiny_tds', '~> 1.0'
   end
 end
 

data/README.md

@@ -21,7 +21,7 @@ Or install it yourself as:
 
 ## Usage
 
-Load the `MySQL` client (for `MSSQL` simple change 'mysql2' to 'tiny_tds'; for
+Load the `MySQL` client (for `MSSQL` simply change 'mysql2' to 'tiny_tds'; for
 `PostgreSQL` simply change 'mysql2' to 'pg' -- when using this gem in a JRuby
 environment the 'jdbc/jtds', 'jdbc/mysql' and/or 'jdbc/postgres'library must be
 installed/available)
@@ -39,11 +39,11 @@ Define the `Column(s)` (available column-types: `Boolean`, `CreatedTimestamp`,
 `UpdatedTimestamp` & `UUID` -- the `Id`, `CreatedTimestamp` & `UpdatedTimestamp`
 columns are required for all `BaseSyncable` tables)
 ```ruby
-id_column = Purview::Columns::Id.new(:id),
-name_column = Purview::Columns::String.new(:name, :nullable => false),
-email_column = Purview::Columns::String.new(:email, :nullable => false, :limit => 100),
-created_at_column = Purview::Columns::CreatedTimestamp.new(:created_at),
-updated_at_column = Purview::Columns::UpdatedTimestamp.new(:updated_at),
+id_column = Purview::Columns::Id.new(:id)
+name_column = Purview::Columns::String.new(:name, :nullable => false)
+email_column = Purview::Columns::String.new(:email, :nullable => false, :limit => 100)
+created_at_column = Purview::Columns::CreatedTimestamp.new(:created_at)
+updated_at_column = Purview::Columns::UpdatedTimestamp.new(:updated_at)
 
 columns = [
   id_column,
@@ -58,32 +58,24 @@ Define the `Indices` (availble index-types: `Composite` & `Simple`). By default
 `Indices` will be added for the required column-types (`CreatedTimestamp` &
 `UpdatedTimestamp`)
 ```ruby
-indices = [
-  Purview::Indices::Simple.new(email_column, :unique => true),
-]
+indices = [Purview::Indices::Simple.new(email_column, :unique => true)]
 ```
 
 Configure the `Puller` (available puller-types: `MSSQL`, `MySQL`, `PostgreSQL` &
 `URI`)
 ```ruby
-puller_opts = {
-  :type => Purview::Pullers::URI,
-  :uri => 'http://feed.test.com/users',
-}
+puller_opts = {:type => Purview::Pullers::URI, :uri => 'http://feed.test.com/users'}
 ```
 
 Configure the `Parser` (available parser-types: `CSV`, `SQL` & `TSV`)
 ```ruby
-parser_opts = {
-  :type => Purview::Parsers::TSV,
-}
+parser_opts = {:type => Purview::Parsers::TSV}
 ```
 
-Configure the `Loader` (for `PostgreSQL` simply change `MySQL` to `PostgreSQL`)
+Configure the `Loader` (for a different loader type simply change `MySQL` to
+`MSSQL`, `PostgreSQL` or `SQLite`)
 ```ruby
-loader_opts = {
-  :type => Purview::Loaders::MySQL,
-}
+loader_opts = {:type => Purview::Loaders::MySQL}
 ```
 
 Combine all the configuration options and instantiate the `Table`
@@ -96,10 +88,7 @@ table_opts = {
   :puller => puller_opts,
 }
 
-table = Purview::Tables::Raw.new(
-  table_name,
-  table_opts
-)
+table = Purview::Tables::Raw.new(table_name, table_opts)
 ```
 
 Set the database-name (this can be anything, but it must exist)
@@ -107,22 +96,19 @@ Set the database-name (this can be anything, but it must exist)
 database_name = :data_warehouse_raw
 ```
 
-Combine all the configuration options and instantiate the `Database` (for
-`PostgreSQL` simply change `MySQL` to `PostgreSQL`)
+Combine all the configuration options and instantiate the `Database` (for a
+different database engine simply change `MySQL` to `MSSQL`, `PostgreSQL` or
+`SQLite`)
 ```ruby
-database_opts = {
-  :tables => [table],
-}
+database_opts = {:tables => [table]}
 
-database = Purview::Databases::MySQL.new(
-  database_name,
-  database_opts
-)
+database = Purview::Databases::MySQL.new(database_name, database_opts)
 ```
 
 Create the `Table` (in the DB). Recommended for testing purposes *only*. For
 production environments you will likely want an external process to manage the
-schema (for `PostgreSQL` simply change `Mysql2::Error` to `PG::DuplicateTable`)
+schema (for `PostgreSQL` simply change `Mysql2::Error` to `PG::DuplicateTable`,
+for `SQLite` simply change `Mysql2::Error` to `SQLite3::SQLException`, etc.)
 ```ruby
 begin
   database.create_table(table)
@@ -135,9 +121,11 @@ Initialize the `Table` (in the DB). This process sets the `max_timestamp_pulled`
 value in the `table_metadata` table and is used by the candidate `Table`
 selection algorithm to determine which `Table` should be synchronized next (the
 least recently synchronized `Table` will be selected). This value is also used
-as the high-water mark for records pulled from its source
+as the high-water mark for records pulled from its source. Unless a `timestamp`
+is specified, as the second argument, the high-water mark will default to
+`Time.now.utc`
 ```ruby
-database.initialize_table(table, timestamp)
+database.initialize_table(table)
 ```
 
 Baseline the `Table`. This process will quickly get the state of the `Table` as
@@ -156,6 +144,15 @@ to determine the pool of `Table(s)` available for synchronization (to remove a
 database.enable_table(table)
 ```
 
+Disable the `Table` (in the DB). This process clears the `enabled_at` value in
+the `table_metadata` table which will remove the table from the candidate `Table`
+selection algorithm used to determine the pool of `Table(s)` available for
+synchronization (to add a `Table` back into the pool, simply execute
+`enable_table`)
+```ruby
+database.disable_table(table)
+```
+
 Sync the `Table`. This process will pull data from its [remote-]source and
 reconcile the new data against the main-table (e.g. perform 'INSERT', 'UPDATE'
 and 'DELETE' operations).

data/TODO

@@ -1,89 +1,54 @@
-... CLOSED TASKS ....
-
-* Handle blank values a bit more intelligently (all blanks -> nil)
-  * Add support for INSERTs, UPDATEs and DELETEs (of table-data)
-* Deal w/ NULL values
-* Deal w/ BOOL values
-* Build out MVP for PostgreSQL loader
-  * Create temporary table from table-metadata and load all of the parsed rows
-    into it (build create, update and delete logic atop the temporary table)
-  * Map [object-]types to database types (in the loader?)
-* Add windowing to pulls (simulate w/ 2 different data-files if necessary)
-  * Store max-timestamp pulled (NULL or previous window + window size)
-  * Add configuration to `Table` for window-size (in the future this can scale
-    dynamically)
-* Include [window] timestamps in query-string for pull[er]
-* Figure out an intelligent way to solve the chicken <-> egg problem for
-  `table_metadata`
-* Fail fast if there are no candidate tables (`next_table`)
-* Ensure that the puller does not try to go into the future (`next_window`)
-* Add in a primitive logging facility (can be temporary)
-* Enhance `next_table_sql`
-* Lock tables (feeds) during pull, parse and load
-* Verify table-locking mechanism behaves as expected
-* Ability to drop a table
-* Reorder args: "table, table_name" to: "table_name, table"
-* Reorder args: "table, index_name, *columns" to "index_name, table, *columns"
-* Ability to create an index
-* Ability to drop an index
-* Indices on `created_at` and `updated_at` columns
-* Gracefully handle table {,un}locking in case of error
-* Add debugging code
-* Raise no-window & no-table exceptions (making them catchable upstream)
-* Minimize race-condition around table-locking (use where on UPDATE, raise if
-  zero rows are updated)
-* Log number of delete, inserts and updates in `loader`
-* `load_temporary_table` should bomb if there is data outside the window
-* Delete from outside window where id in temporary table
-* Rename `data` to `rows` in `execute`
-* Rename `Postgres` to `PostgreSQL`
-* Finish PostgreSQL support (requires `pg` gem)
-* Finish MySQL support (requires `mysql2` gem)
-* Usage/configuration examples in README.md
-* Create SQL-puller(s)
-* Introduce [SQL] dialect(s)
-* Fix JRuby bundle/build
-* Fall back to logged in user if no [database-]username is provided
-* Create class to encapulate `table_metadata` (in order to clean up the logic
-  in the `Database` class(es))
-* Rename columns during pull/parse `source_name` & `target_name` perhaps? Maybe
-  create a new type of column?
-
-... ONGOING TASKS ...
-
-* Add tests
-* Add comments where appropriate
-* DRY/Refactor
-
-... OPEN TASKS ....
-
-* Add COPY `def copy(sql)` support to PostgreSQL connection
-* Leverage COPY support for PostgreSQL pulls
-* Further encapsulate `Dialect` logic (in order to DRY `Database` classes)
-* Add support for MSSQL
-
-* Build out change-log tables
-* Build out canonical, fact and aggregate tables (and related transforms)
-* Configurable re-pull window (do this automatically once up to current?)
-* Add schema management capabilities (detect schema-deltas and suggestion
-  modifications)
-* Consider refactoring mutator methods to be globally available (e.g. quoted ->
-  Quote, etc.)
-
-... CLOSED QUESTIONS ...
-
-* Where is the best place to create the connection?
-  * Immediately? Then it's open during the pull, etc.
-  * Lazily? Makes for connection logic all over the place
-    * Perhaps it can be centralized entirely into the `Database` class?
-* Consider using ISO-8601 timestamps in query-string (not sure on this one, it
-  is slightly more fragile because of URL-encoding, etc.)
-
-... OPEN QUESTIONS ...
-
-* Parallel pulls from the same "source"? Can this be done in one request?
-
-... INTEGRATION CONSIDERATIONS ...
-
-* Deployment
-* Scheduling (Daemon? CRON?)
+a	1450000000	1450000000	Add COPY `def copy(sql)` support to PostgreSQL connection
+a	1450000000	1450000000	Leverage COPY support for PostgreSQL pulls
+a	1450000000	1450000000	Build out change-log tables
+a	1450000000	1450000000	Build out canonical, fact and aggregate tables (and related transforms)
+a	1450000000	1450000000	Configurable re-pull window (do this automatically once up to current?)
+a	1450000000	1450000000	Add schema management capabilities (detect schema-deltas and suggestion modifications)
+a	1450000000	1450000000	Consider refactoring mutator methods to be globally available (e.g. quoted -> Quote, etc.)
+a	1450000000	1450000000	Support parallel pulls?
+a	1450000000	1450000000	Come up w/ a deployment recommendation
+r	1450000000	1450000000	Add support for MSSQL
+r	1450000000	1495070870	Further encapsulate `Dialect` logic (in order to DRY `Database` classes)
+d	1494850714	1495046648	Finish SQLite3 raw-connections
+d	1495046665	1495046689	Fix JDBC driver configuration
+d	1495051831	1495070248	Code-review recent changes and merge
+d	1450000000	1450000000	Handle blank values a bit more intelligently (all blanks -> nil)
+d	1450000000	1450000000	Deal w/ NULL values
+d	1450000000	1450000000	Deal w/ BOOL values
+d	1450000000	1450000000	Build out MVP for PostgreSQL loader
+d	1450000000	1450000000	Add windowing to pulls (simulate w/ 2 different data-files if necessary)
+d	1450000000	1450000000	Include [window] timestamps in query-string for pull[er]
+d	1450000000	1450000000	Figure out an intelligent way to solve the chicken <-> egg problem for `table_metadata`
+d	1450000000	1450000000	Fail fast if there are no candidate tables (`next_table`)
+d	1450000000	1450000000	Ensure that the puller does not try to go into the future (`next_window`)
+d	1450000000	1450000000	Add in a primitive logging facility (can be temporary)
+d	1450000000	1450000000	Enhance `next_table_sql`
+d	1450000000	1450000000	Lock tables (feeds) during pull, parse and load
+d	1450000000	1450000000	Verify table-locking mechanism behaves as expected
+d	1450000000	1450000000	Ability to drop a table
+d	1450000000	1450000000	Reorder args: "table, table_name" to: "table_name, table"
+d	1450000000	1450000000	Reorder args: "table, index_name, *columns" to "index_name, table, *columns"
+d	1450000000	1450000000	Ability to create an index
+d	1450000000	1450000000	Ability to drop an index
+d	1450000000	1450000000	Indices on `created_at` and `updated_at` columns
+d	1450000000	1450000000	Gracefully handle table {,un}locking in case of error
+d	1450000000	1450000000	Add debugging code
+d	1450000000	1450000000	Raise no-window & no-table exceptions (making them catchable upstream)
+d	1450000000	1450000000	Minimize race-condition around table-locking (use where on UPDATE, raise if zero rows are updated)
+d	1450000000	1450000000	Log number of delete, inserts and updates in `loader`
+d	1450000000	1450000000	`load_temporary_table` should bomb if there is data outside the window
+d	1450000000	1450000000	Delete from outside window where id in temporary table
+d	1450000000	1450000000	Rename `data` to `rows` in `execute`
+d	1450000000	1450000000	Rename `Postgres` to `PostgreSQL`
+d	1450000000	1450000000	Finish PostgreSQL support (requires `pg` gem)
+d	1450000000	1450000000	Finish MySQL support (requires `mysql2` gem)
+d	1450000000	1450000000	Usage/configuration examples in README.md
+d	1450000000	1450000000	Create SQL-puller(s)
+d	1450000000	1450000000	Introduce [SQL] dialect(s)
+d	1450000000	1450000000	Fix JRuby bundle/build
+d	1450000000	1450000000	Fall back to logged in user if no [database-]username is provided
+d	1450000000	1450000000	Create class to encapulate `table_metadata` (in order to clean up the logic in the `Database` class(es))
+d	1450000000	1450000000	Rename columns during pull/parse `source_name` & `target_name` perhaps? Maybe create a new type of column?
+d	1450000000	1495070826	Add support for SQLite3
+d	1494850696	1495070857	Add TODOs from $HOME\purview-TODO
+d	1495070065	1495072292	Finish MSSQL built-out

data/lib/purview/connections.rb

@@ -1,4 +1,6 @@
 require 'purview/connections/base'
+
 require 'purview/connections/mssql'
 require 'purview/connections/mysql'
 require 'purview/connections/postgresql'
+require 'purview/connections/sqlite'

data/lib/purview/connections/sqlite.rb

@@ -0,0 +1,11 @@
+module Purview
+  module Connections
+    class SQLite < Base
+      private
+
+      def raw_connection_type
+        Purview::RawConnections::SQLite
+      end
+    end
+  end
+end

data/lib/purview/databases.rb

@@ -1,4 +1,6 @@
 require 'purview/databases/base'
 
+require 'purview/databases/mssql'
 require 'purview/databases/mysql'
 require 'purview/databases/postgresql'
+require 'purview/databases/sqlite'

data/lib/purview/databases/base.rb

@@ -13,7 +13,7 @@ module Purview
         end
       end
 
-      def baseline_table(table)
+      def baseline_table(table, timestamp=Time.now.utc)
         ensure_table_valid_for_database(table)
         raise Purview::Exceptions::CouldNotBaselineTable.new(table) \
           unless table_initialized?(table)
@@ -84,7 +84,7 @@ module Purview
         table_name
       end
 
-      def disable_table(table)
+      def disable_table(table, timestamp=Time.now.utc)
         ensure_table_valid_for_database(table)
         table_name = table_name(table)
         with_context_logging("`disable_table` for: #{table_name}") do
@@ -142,7 +142,7 @@ module Purview
         table_name
       end
 
-      def enable_table(table, timestamp=timestamp)
+      def enable_table(table, timestamp=Time.now.utc)
         ensure_table_valid_for_database(table)
         table_name = table_name(table)
         with_context_logging("`enable_table` for: #{table_name}") do
@@ -156,7 +156,7 @@ module Purview
         table_name
       end
 
-      def initialize_table(table, timestamp=timestamp)
+      def initialize_table(table, timestamp=Time.now.utc)
         ensure_table_valid_for_database(table)
         table_name = table_name(table)
         with_context_logging("`initialize_table` for: #{table_name}") do
@@ -170,7 +170,7 @@ module Purview
         table_name
       end
 
-      def lock_table(table, timestamp=timestamp)
+      def lock_table(table, timestamp=Time.now.utc)
         ensure_table_valid_for_database(table)
         table_name = table_name(table)
         with_context_logging("`lock_table` for: #{table_name}") do
@@ -194,7 +194,7 @@ module Purview
         end
       end
 
-      def sync_table(table)
+      def sync_table(table, timestamp=Time.now.utc)
         ensure_table_valid_for_database(table)
         raise Purview::Exceptions::CouldNotSyncTable.new(table) \
           unless table_initialized?(table) && table_enabled?(table)
@@ -211,7 +211,7 @@ module Purview
         table_name = table_name(table)
         with_context_logging("`table_metadata` for: #{table_name}") do
           with_new_connection do |connection|
-            Purview::Structs::TableMetadata.new(
+            table_metadata = Purview::Structs::TableMetadata.new(
               table_metadata_table.columns.reduce({}) do |memo, column|
                 memo[column.name] = get_table_metadata_value(
                   connection,

data/lib/purview/databases/mssql.rb

@@ -0,0 +1,180 @@
+module Purview
+  module Databases
+    class MSSQL < Base
+      private
+
+      def connection_type
+        Purview::Connections::MSSQL
+      end
+
+      def create_index_sql(table_name, index_name, index, index_opts={})
+        'CREATE%sINDEX %s ON %s (%s)' % [
+          index.unique? ? ' UNIQUE ' : ' ',
+          index_name,
+          table_name,
+          column_names(index).join(', '),
+        ]
+      end
+
+      def create_table_sql(table_name, table, table_opts={})
+        'CREATE TABLE %s (%s)' % [
+          table_name,
+          column_definitions(table).join(', '),
+        ]
+      end
+
+      def create_temporary_table_sql(table_name, table, table_opts={})
+        'CREATE TEMPORARY TABLE %s (%s)' % [
+          table_name,
+          column_definitions(table).join(', '),
+        ]
+      end
+
+      def dialect_type
+        Purview::Dialects::MSSQL
+      end
+
+      def disable_table_sql(table)
+        'UPDATE %s SET %s = %s WHERE %s = %s AND %s IS NOT NULL' % [
+          table_metadata_table.name,
+          table_metadata_table.enabled_at_column.name,
+          null_value,
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+          table_metadata_table.enabled_at_column.name,
+        ]
+      end
+
+      def drop_index_sql(table_name, index_name, index, index_opts={})
+        'DROP INDEX %s' % [
+          index_name,
+        ]
+      end
+
+      def drop_table_sql(table_name, table, table_opts={})
+        'DROP TABLE %s' % [
+          table_name,
+        ]
+      end
+
+      def enable_table_sql(table, timestamp)
+        'UPDATE %s SET %s = %s WHERE %s = %s AND %s IS NULL' % [
+          table_metadata_table.name,
+          table_metadata_table.enabled_at_column.name,
+          quoted(timestamp),
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+          table_metadata_table.enabled_at_column.name,
+        ]
+      end
+
+      def ensure_table_metadata_absent_for_table_sql(table)
+        'DELETE FROM %s WHERE %s = %s' % [
+          table_metadata_table.name,
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+        ]
+      end
+
+      def ensure_table_metadata_exists_for_table_sql(table)
+        'INSERT INTO %s (%s) SELECT %s WHERE NOT EXISTS (SELECT 1 FROM %s WHERE %s = %s)' % [
+          table_metadata_table.name,
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+          table_metadata_table.name,
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+        ]
+      end
+
+      def ensure_table_metadata_table_exists_sql
+        'CREATE TABLE IF NOT EXISTS %s (%s)' % [
+          table_metadata_table.name,
+          column_definitions(table_metadata_table).join(', '),
+        ]
+      end
+
+      def initialize_table_sql(table, timestamp)
+        'UPDATE %s SET %s = %s WHERE %s = %s AND %s IS NULL' % [
+          table_metadata_table.name,
+          table_metadata_table.max_timestamp_pulled_column.name,
+          quoted(timestamp),
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+          table_metadata_table.max_timestamp_pulled_column.name,
+        ]
+      end
+
+      def get_table_metadata_value_sql(table, column)
+        'SELECT %s FROM %s WHERE %s = %s' % [
+          column.name,
+          table_metadata_table.name,
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+        ]
+      end
+
+      def limit_map
+        super.merge(Purview::Types::String => 255)
+      end
+
+      def limitless_types
+        super + [
+          Purview::Types::Money,
+          Purview::Types::UUID,
+        ]
+      end
+
+      def lock_table_sql(table, timestamp)
+        'UPDATE %s SET %s = %s WHERE %s = %s AND %s IS NULL' % [
+          table_metadata_table.name,
+          table_metadata_table.locked_at_column.name,
+          quoted(timestamp),
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+          table_metadata_table.locked_at_column.name,
+        ]
+      end
+
+      def next_table_sql(timestamp)
+        'SELECT TOP 1 %s FROM %s WHERE %s IS NOT NULL AND %s IS NOT NULL AND %s IS NULL ORDER BY (CASE WHEN %s IS NULL THEN 0 ELSE 1 END), %s' % [
+          table_metadata_table.table_name_column.name,
+          table_metadata_table.name,
+          table_metadata_table.enabled_at_column.name,
+          table_metadata_table.max_timestamp_pulled_column.name,
+          table_metadata_table.locked_at_column.name,
+          table_metadata_table.last_pulled_at_column.name,
+          table_metadata_table.last_pulled_at_column.name,
+        ]
+      end
+
+      def set_table_metadata_value_sql(table, column, value)
+        'UPDATE %s SET %s = %s WHERE %s = %s' % [
+          table_metadata_table.name,
+          column.name,
+          quoted(value),
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+        ]
+      end
+
+      def type_map
+        super.merge(
+          Purview::Types::Money => 'money',
+          Purview::Types::UUID => 'uniqueidentifier',
+        )
+      end
+
+      def unlock_table_sql(table)
+        'UPDATE %s SET %s = %s WHERE %s = %s AND %s IS NOT NULL' % [
+          table_metadata_table.name,
+          table_metadata_table.locked_at_column.name,
+          null_value,
+          table_metadata_table.table_name_column.name,
+          quoted(table.name),
+          table_metadata_table.locked_at_column.name,
+        ]
+      end
+    end
+  end
+end