activerecord-spanner-adapter 0.3.0 → 1.0.0

data/lib/active_record/connection_adapters/spanner/quoting.rb

@@ -1,66 +1,58 @@
-# -*- frozen_string_literal: true -*-
-require 'json'
+# The MIT License (MIT)
+#
+# Copyright (c) 2020 Google LLC.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# ITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+# Copyright 2020 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+# frozen_string_literal: true
 
 module ActiveRecord
   module ConnectionAdapters
     module Spanner
       module Quoting
-        IDENTIFIERS_PATTERN = /\A[a-zA-Z][a-zA-Z0-9_]*\z/
-
-        def quote_identifier(name)
-          # https://cloud.google.com/spanner/docs/data-definition-language?hl=ja#ddl_syntax
-          # raise ArgumentError, "invalid table name #{name}" unless IDENTIFIERS_PATTERN =~ name
-          "`#{name}`"
+        def quote_column_name name
+          self.class.quoted_column_names[name] ||= "`#{super.gsub '`', '``'}`".freeze
         end
 
-        alias quote_table_name quote_identifier
-        alias quote_column_name quote_identifier
-
-        private
-        def _type_cast(value)
-          # NOTE: Spanner APIs are strongly typed unlike typical SQL interfaces.
-          # So we don't want to serialize the value into string unlike other adapters.
-          case value
-          when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-            value.to_s
-          else
-            value
-          end
+        def quote_table_name name
+          self.class.quoted_table_names[name] ||= super.gsub(".", "`.`").freeze
         end
 
-        def _quote(value)
-          case value
-          when Symbol, String, ActiveSupport::Multibyte::Chars, Type::Binary::Data
-            quote_string(value.to_s)
-          when true
-            quoted_true
-          when false
-            quoted_false
-          when nil
-            'NULL'
-          when Numeric, ActiveSupport::Duration
-            value.to_s
-          when Type::Time::Value
-            %Q["#{quoted_time(value)}"]
-          when Date, Time
-            %Q["#{quoted_date(value)}"]
-          else
-            raise TypeError, "can't quote #{value.class.name}"
-          end
-        end
+        STR_ESCAPE_REGX = /[\n\r'\\]/.freeze
+        STR_ESCAPE_VALUES = {
+          "\n" => "\\n", "\r" => "\\r", "'" => "\\'", "\\" => "\\\\"
+        }.freeze
 
-        def quote_string(value)
-          # Not sure but string-escape syntax in SELECT statements in Spanner
-          # looks to be the one in JSON by observation.
-          JSON.generate(value)
-        end
+        private_constant :STR_ESCAPE_REGX, :STR_ESCAPE_VALUES
 
-        def quoted_true
-          'true'
+        def quote_string s
+          s.gsub STR_ESCAPE_REGX, STR_ESCAPE_VALUES
         end
 
-        def quoted_false
-          'false'
+        def quoted_binary value
+          "b'#{value}'"
         end
       end
     end

data/lib/active_record/connection_adapters/spanner/schema_cache.rb

@@ -0,0 +1,43 @@
+# Copyright 2020 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+module ActiveRecord
+  module ConnectionAdapters
+    class SpannerSchemaCache < SchemaCache
+      def initialize conn
+        @primary_and_parent_keys = {}
+        super
+      end
+
+      def initialize_dup other
+        @primary_and_parent_keys = @primary_and_parent_keys.dup
+        super
+      end
+
+      def encode_with coder
+        coder["primary_and_parent_keys"] = @primary_and_parent_keys
+        super
+      end
+
+      def init_with coder
+        @primary_and_parent_keys = coder["primary_and_parent_keys"]
+        super
+      end
+
+      def primary_and_parent_keys table_name
+        @primary_and_parent_keys[table_name] ||=
+          if data_source_exists? table_name
+            connection.primary_and_parent_keys table_name
+          end
+      end
+
+      def clear!
+        @primary_and_parent_keys.clear
+        super
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/spanner/schema_creation.rb

@@ -1,22 +1,138 @@
+# Copyright 2020 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
 module ActiveRecord
   module ConnectionAdapters
     module Spanner
-      class DDL < String; end
+      class SchemaCreation < SchemaCreation
+        private
+
+        # rubocop:disable Naming/MethodName, Metrics/AbcSize
+
+        def visit_TableDefinition o
+          create_sql = +"CREATE TABLE #{quote_table_name o.name} "
+          statements = o.columns.map { |c| accept c }
+
+          o.foreign_keys.each do |to_table, options|
+            statements << foreign_key_in_create(o.name, to_table, options)
+          end
+
+          create_sql << "(#{statements.join ', '}) " if statements.any?
+
+          primary_keys = if o.primary_keys
+                           o.primary_keys
+                         else
+                           pk_names = o.columns.each_with_object [] do |c, r|
+                             if c.type == :primary_key || c.primary_key?
+                               r << c.name
+                             end
+                           end
+                           PrimaryKeyDefinition.new pk_names
+                         end
+
+          if o.interleave_in?
+            parent_names = o.columns.each_with_object [] do |c, r|
+              if c.type == :parent_key
+                r << c.name
+              end
+            end
+            primary_keys.name = parent_names.concat primary_keys.name
+            create_sql << accept(primary_keys)
+            create_sql << ", INTERLEAVE IN PARENT #{quote_table_name o.interleave_in_parent}"
+            create_sql << " ON DELETE #{o.on_delete}" if o.on_delete
+          else
+            create_sql << accept(primary_keys)
+          end
+
+          create_sql
+        end
+
+        def visit_DropTableDefinition o
+          "DROP TABLE #{quote_table_name o.name}"
+        end
+
+        def visit_ColumnDefinition o
+          o.sql_type = type_to_sql o.type, **o.options
+          column_sql = +"#{quote_column_name o.name} #{o.sql_type}"
+          add_column_options! column_sql, column_options(o)
+          column_sql
+        end
+
+        def visit_AddColumnDefinition o
+          # Overridden to add the optional COLUMN keyword. The keyword is only optional
+          # on real Cloud Spanner, the emulator requires the COLUMN keyword to be included.
+          +"ADD COLUMN #{accept o.column}"
+        end
+
+        def visit_DropColumnDefinition o
+          "ALTER TABLE #{quote_table_name o.table_name} DROP" \
+           " COLUMN #{quote_column_name o.name}"
+        end
 
-      class SchemaCreation < AbstractAdapter::SchemaCreation
-        def visit_TableDefinition(o)
-          pk = o.columns.find {|c| c.options[:primary_key] }
-          ddl = "#{super} PRIMARY KEY (#{quote_column_name(pk.name)})"
-          DDL.new(ddl)
+        def visit_ChangeColumnDefinition o
+          sql = +"ALTER TABLE #{quote_table_name o.table_name} ALTER COLUMN "
+          sql << accept(o.column)
+          sql
         end
 
-        def add_column_options!(sql, options)
-          if options[:null] == false
+        def visit_DropIndexDefinition o
+          "DROP INDEX #{quote_table_name o.name}"
+        end
+
+        def visit_IndexDefinition o
+          sql = +"CREATE"
+          sql << " UNIQUE" if o.unique
+          sql << " NULL_FILTERED" if o.null_filtered
+          sql << " INDEX #{quote_table_name o.name} "
+
+          columns_sql = o.columns_with_order.map do |c, order|
+            order_sql = +quote_column_name(c)
+            order_sql << " DESC" if order == "DESC"
+            order_sql
+          end
+
+          sql << "ON #{quote_table_name o.table} (#{columns_sql.join ', '})"
+
+          if o.storing.any?
+            storing = o.storing.map { |s| quote_column_name s }
+            sql << " STORING (#{storing.join ', '})"
+          end
+          if o.interleave_in
+            sql << ", INTERLEAVE IN #{quote_table_name o.interleave_in}"
+          end
+          sql
+        end
+
+        # rubocop:enable Naming/MethodName, Metrics/AbcSize
+
+        def add_column_options! sql, options
+          if options[:null] == false || options[:primary_key] == true
             sql << " NOT NULL"
           end
+
+          if !options[:allow_commit_timestamp].nil? &&
+             options[:column].sql_type == "TIMESTAMP"
+            sql << " OPTIONS (allow_commit_timestamp = "\
+                   "#{options[:allow_commit_timestamp]})"
+          end
+
+          if (as = options[:as])
+            sql << " AS (#{as})"
+
+            sql << " STORED" if options[:stored]
+            unless options[:stored]
+              raise ArgumentError, "" \
+                "Cloud Spanner currently does not support generated columns without the STORED option." \
+                "Specify 'stored: true' option for `#{options[:column].name}`"
+            end
+          end
+
+          sql
         end
       end
     end
   end
 end
-

data/lib/active_record/connection_adapters/spanner/schema_definitions.rb

@@ -0,0 +1,122 @@
+# Copyright 2020 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+module ActiveRecord
+  module ConnectionAdapters #:nodoc:
+    module Spanner
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        attr_reader :interleave_in_parent
+
+        def interleave_in parent, on_delete = nil
+          @interleave_in_parent = parent
+          @on_delete = on_delete
+        end
+
+        def parent_key name
+          column name, :parent_key, null: false
+        end
+
+        def interleave_in?
+          @interleave_in_parent != nil
+        end
+
+        def on_delete
+          "CASCADE" if @on_delete == :cascade
+        end
+
+        def references *args, **options
+          args.each do |ref_name|
+            Spanner::ReferenceDefinition.new(ref_name, **options).add_to(self)
+          end
+        end
+        alias belongs_to references
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        def primary_key name, type = :primary_key, **options
+          type = :string # rubocop:disable Lint/ShadowedArgument
+          options.merge primary_key: true
+          super
+        end
+      end
+
+      DropTableDefinition = Struct.new :name, :options
+      DropColumnDefinition = Struct.new :table_name, :name
+      ChangeColumnDefinition = Struct.new :table_name, :column, :name
+      DropIndexDefinition = Struct.new :name
+
+      class ReferenceDefinition < ActiveRecord::ConnectionAdapters::ReferenceDefinition
+        def initialize \
+            name,
+            polymorphic: false,
+            index: true,
+            foreign_key: false,
+            type: :integer,
+            **options
+          @name = name
+          @polymorphic = polymorphic
+          @foreign_key = foreign_key
+          # Only add an index if there is no foreign key, as Cloud Spanner will automatically add a managed index when
+          # a foreign key is added.
+          @index = index unless foreign_key
+          @type = type
+          @options = options
+
+          return unless polymorphic && foreign_key
+          raise ArgumentError, "Cannot add a foreign key to a polymorphic relation"
+        end
+
+        private
+
+        def columns
+          result = [[column_name, type, options]]
+
+          if polymorphic
+            type_options = polymorphic_options.merge limit: 255
+            result.unshift ["#{name}_type", :string, type_options]
+          end
+          result
+        end
+      end
+
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
+        attr_reader :null_filtered, :interleave_in, :storing, :orders
+
+        def initialize \
+            table_name,
+            name,
+            columns,
+            unique: false,
+            null_filtered: false,
+            interleave_in: nil,
+            storing: nil,
+            orders: nil
+          @table = table_name
+          @name = name
+          @unique = unique
+          @null_filtered = null_filtered
+          @interleave_in = interleave_in
+          @storing = Array(storing)
+          columns = columns.split(/\W/) if columns.is_a? String
+          @columns = Array(columns).map(&:to_s)
+          @orders = orders || {}
+
+          unless @orders.is_a? Hash
+            @orders = columns.each_with_object({}) { |c, r| r[c] = orders }
+          end
+
+          @orders = @orders.symbolize_keys
+        end
+
+        def columns_with_order
+          columns.each_with_object({}) do |c, result|
+            result[c] = orders[c.to_sym].to_s.upcase
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/spanner/schema_dumper.rb

@@ -0,0 +1,19 @@
+# Copyright 2020 Google LLC
+#
+# Use of this source code is governed by an MIT-style
+# license that can be found in the LICENSE file or at
+# https://opensource.org/licenses/MIT.
+
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module Spanner
+      class SchemaDumper < ConnectionAdapters::SchemaDumper # :nodoc:
+        def default_primary_key? column
+          schema_type(column) == :integer
+        end
+      end
+    end
+  end
+end