Merge branch 'main' into sort-key-improvement

Author: miguilimzero

README.md

@@ -270,6 +270,22 @@ Schema::create('table', function (Blueprint $table) {
 });
 ```
 
+### Sort Keys - Columnstore variables
+
+Sometimes you may want to customize your [columstore variables](https://docs.singlestore.com/managed-service/en/create-a-database/physical-database-schema-design/procedures-for-physical-database-schema-design/configuring-the-columnstore-to-work-effectively.html) individually per table. You can do it by appending `with` fluently to the `sortKey` definition.
+
+```php
+Schema::create('table', function (Blueprint $table) {
+    $table->string('name');
+
+    $table->sortKey('name')->with(['columnstore_segment_rows' => 100000]);
+});
+
+Schema::create('table', function (Blueprint $table) {
+    $table->string('name')->sortKey()->with(['columnstore_segment_rows' => 100000]);
+});
+```
+
 ### Series Timestamps
 To denote a column as a series timestamp, use the `seriesTimestamp` column modifier.
 
@@ -294,6 +310,20 @@ Schema::create('test', function (Blueprint $table) {
 });
 ```
 
+### Increment Columns without Primary Key
+
+Sometimes you may want to set a custom primary key. However if your table has an int `increment` column,
+Laravel, by default, always sets this column as the primary key. Even if you manually set another one. This behavior can be disabled using the `withoutPrimaryKey` method.
+
+```php
+Schema::create('test', function (Blueprint $table) {
+    $table->id()->withoutPrimaryKey();
+    $table->uuid('uuid');
+    
+    $table->primaryKey(['id',  'uuid']);
+});
+```
+
 ## Testing
 
 Execute the tests using PHPUnit

src/Schema/Blueprint/InlinesIndexes.php

@@ -118,9 +118,15 @@ protected function addFluentSingleStoreIndexes()
             foreach ($this->singleStoreIndexes as $index) {
                 if (isset($column->{$index})) {
                     if ($column->{$index} === true) {
-                        $this->{$index}($column->name);
+                        $command = $this->{$index}($column->name);
                     } else {
-                        $this->{$index}($column->name, $column->{$index});
+                        $command = $this->{$index}($column->name, $column->{$index});
+                    }
+
+                    // Forward with attributes if sortKey
+                    if ($index === 'sortKey' && isset($column->with)) {
+                        $command->with($column->with);
+                        $column->with = null;
                     }
 
                     $column->{$index} = false;

src/Schema/Grammar.php

@@ -190,5 +190,21 @@ protected function columnizeWithDirection(array $columns, string $direction)
         return implode(", ", array_map(function ($column) use ($direction) {
             return $column . ' ' . $direction;
         }, $wrapped));
+     }
+     
+    /**
+     * Get the SQL for an auto-increment column modifier.
+     *
+     * @param  \Illuminate\Database\Schema\Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent  $column
+     * @return string|null
+     */
+    protected function modifyIncrement(Blueprint $blueprint, Fluent $column)
+    {
+        if (in_array($column->type, $this->serials) && $column->autoIncrement) {
+            return ($column->withoutPrimaryKey === true)
+                ? ' auto_increment'
+                : ' auto_increment primary key';
+        }
     }
 }

src/Schema/Grammar/CompilesKeys.php

@@ -17,6 +17,14 @@ public function compileShardKey(Blueprint $blueprint, Fluent $command)
 
     public function compileSortKey(Blueprint $blueprint, Fluent $command)
     {
+        if (is_array($command->with)) {
+            $compiled = collect($command->with)->map(function ($value, $variable) {
+                return "{$variable}={$value}";
+            })->join(',');
+
+            return "sort key({$this->columnizeWithDirection($command->columns, $command->direction)}) with ({$compiled})";
+        }
+
         return "sort key({$this->columnizeWithDirection($command->columns, $command->direction)})";
     }
 

tests/Hybrid/CreateTable/IncrementWithoutPrimaryKeyTest.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * @author https://github.com/srdante
+ */
+
+namespace SingleStore\Laravel\Tests\Hybrid\CreateTable;
+
+use SingleStore\Laravel\Schema\Blueprint;
+use SingleStore\Laravel\Tests\BaseTest;
+use SingleStore\Laravel\Tests\Hybrid\HybridTestHelpers;
+
+class IncrementWithoutPrimaryKeyTest extends BaseTest
+{
+    use HybridTestHelpers;
+
+    /** @test */
+    public function it_adds_a_big_increments_without_primary_key()
+    {
+        $blueprint = $this->createTable(function (Blueprint $table) {
+            $table->bigIncrements('id')->withoutPrimaryKey();
+            $table->uuid('uuid');
+
+            $table->primary(['id', 'uuid']);
+        });
+
+        $this->assertCreateStatement(
+            $blueprint,
+            'create table `test` (`id` bigint unsigned not null auto_increment, `uuid` char(36) not null, primary key `test_id_uuid_primary`(`id`, `uuid`))'
+        );
+    }
+
+    /** @test */
+    public function it_adds_an_id_without_primary_key()
+    {
+        $blueprint = $this->createTable(function (Blueprint $table) {
+            $table->id()->withoutPrimaryKey();
+            $table->uuid('uuid');
+
+            $table->primary(['id', 'uuid']);
+        });
+
+        $this->assertCreateStatement(
+            $blueprint,
+            'create table `test` (`id` bigint unsigned not null auto_increment, `uuid` char(36) not null, primary key `test_id_uuid_primary`(`id`, `uuid`))'
+        );
+    }
+}

tests/Hybrid/CreateTable/SortKeysTest.php

@@ -94,4 +94,47 @@ public function shard_and_sort_keys()
             'create table `test` (`name` varchar(255) not null, shard key(`name`), sort key(`name` asc))'
         );
     }
+
+    /** @test */
+    public function it_adds_a_sort_key_with_with_statement()
+    {
+        $blueprint = $this->createTable(function (Blueprint $table) {
+            $table->string('name');
+            $table->sortKey('name')->with(['columnstore_segment_rows' => 100000]);
+        });
+
+        $this->assertCreateStatement(
+            $blueprint,
+            'create table `test` (`name` varchar(255) not null, sort key(`name` asc) with (columnstore_segment_rows=100000))'
+        );
+    }
+
+    /** @test */
+    public function it_adds_a_sort_key_fluent_with_with_statement()
+    {
+        $blueprint = $this->createTable(function (Blueprint $table) {
+            $table->string('name')->sortKey()->with(['columnstore_segment_rows' => 100000]);
+        });
+
+        $this->assertCreateStatement(
+            $blueprint,
+            'create table `test` (`name` varchar(255) not null, sort key(`name` asc) with (columnstore_segment_rows=100000))'
+        );
+    }
+
+    /** @test */
+    public function it_adds_a_sort_key_fluent_with_dual_with_statement()
+    {
+        $blueprint = $this->createTable(function (Blueprint $table) {
+            $table->string('name')->sortKey()->with([
+                'columnstore_segment_rows' => 100000,
+                'columnstore_flush_bytes' => 4194304,
+            ]);
+        });
+
+        $this->assertCreateStatement(
+            $blueprint,
+            'create table `test` (`name` varchar(255) not null, sort key(`name` asc) with (columnstore_segment_rows=100000,columnstore_flush_bytes=4194304))'
+        );
+    }
 }