src: generator: hypertable: edition support

Anton Schieber · Anton Schieber · commit 1a11dd5b72c3 · 2025-11-26T21:58:15.000+10:00
Add support for the apache and community editions of timescaledb in the
hypertable generator.
diff --git a/src/Eftdb/Generators/HypertableOperationGenerator.cs b/src/Eftdb/Generators/HypertableOperationGenerator.cs
@@ -1,5 +1,6 @@
 ﻿using CmdScale.EntityFrameworkCore.TimescaleDB.Abstractions;
 using CmdScale.EntityFrameworkCore.TimescaleDB.Operations;
+using System.Text;
 
 namespace CmdScale.EntityFrameworkCore.TimescaleDB.Generators
 {
@@ -16,54 +17,57 @@ public HypertableOperationGenerator(bool isDesignTime = false)
             }
 
             sqlHelper = new SqlBuilderHelper(quoteString);
-
         }
 
         public List<string> Generate(CreateHypertableOperation operation)
         {
             string qualifiedTableName = sqlHelper.Regclass(operation.TableName, operation.Schema);
             string qualifiedIdentifier = sqlHelper.QualifiedIdentifier(operation.TableName, operation.Schema);
 
-            List<string> statements =
-            [
-                $"SELECT create_hypertable({qualifiedTableName}, '{operation.TimeColumnName}');"
-            ];
+            List<string> statements = [];
+            List<string> communityStatements = [];
 
-            // ChunkTimeInterval
+            // Build create_hypertable with chunk_time_interval if provided
+            var createHypertableCall = new StringBuilder();
+            createHypertableCall.Append($"SELECT create_hypertable({qualifiedTableName}, '{operation.TimeColumnName}'");
+            
             if (!string.IsNullOrEmpty(operation.ChunkTimeInterval))
             {
                 // Check if the interval is a plain number (e.g., for microseconds).
                 if (long.TryParse(operation.ChunkTimeInterval, out _))
                 {
                     // If it's a number, don't wrap it in quotes.
-                    statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, {operation.ChunkTimeInterval}::bigint);");
+                    createHypertableCall.Append($", chunk_time_interval => {operation.ChunkTimeInterval}::bigint");
                 }
                 else
                 {
                     // If it's a string like '7 days', wrap it in quotes.
-                    statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, INTERVAL '{operation.ChunkTimeInterval}');");
+                    createHypertableCall.Append($", chunk_time_interval => INTERVAL '{operation.ChunkTimeInterval}'");
                 }
             }
+            
+            createHypertableCall.Append(");");
+            statements.Add(createHypertableCall.ToString());
 
-            // EnableCompression
+            // EnableCompression (Community Edition only)
             if (operation.EnableCompression || operation.ChunkSkipColumns?.Count > 0)
             {
                 bool enableCompression = operation.EnableCompression || operation.ChunkSkipColumns != null && operation.ChunkSkipColumns.Count > 0;
-                statements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {enableCompression.ToString().ToLower()});");
+                communityStatements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {enableCompression.ToString().ToLower()});");
             }
 
-            // ChunkSkipColumns
+            // ChunkSkipColumns (Community Edition only)
             if (operation.ChunkSkipColumns != null && operation.ChunkSkipColumns.Count > 0)
             {
-                statements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");
+                communityStatements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");
 
                 foreach (string column in operation.ChunkSkipColumns)
                 {
-                    statements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");
+                    communityStatements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");
                 }
             }
 
-            // AdditionalDimensions
+            // AdditionalDimensions (Available in both editions)
             if (operation.AdditionalDimensions != null && operation.AdditionalDimensions.Count > 0)
             {
                 foreach (Dimension dimension in operation.AdditionalDimensions)
@@ -85,6 +89,11 @@ public List<string> Generate(CreateHypertableOperation operation)
                 }
             }
 
+            // Add wrapped community statements if any exist
+            if (communityStatements.Count > 0)
+            {
+                statements.Add(WrapCommunityFeatures(communityStatements));
+            }
             return statements;
         }
 
@@ -94,45 +103,52 @@ public List<string> Generate(AlterHypertableOperation operation)
             string qualifiedIdentifier = sqlHelper.QualifiedIdentifier(operation.TableName, operation.Schema);
 
             List<string> statements = [];
+            List<string> communityStatements = [];
 
-            // Check for ChunkTimeInterval change
+            // Check for ChunkTimeInterval change (Available in both editions)
             if (operation.ChunkTimeInterval != operation.OldChunkTimeInterval)
             {
+                var setChunkTimeInterval = new StringBuilder();
+                setChunkTimeInterval.Append($"SELECT set_chunk_time_interval({qualifiedTableName}, ");
+                
                 // Check if the interval is a plain number (e.g., for microseconds).
                 if (long.TryParse(operation.ChunkTimeInterval, out _))
                 {
                     // If it's a number, don't wrap it in quotes.
-                    statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, {operation.ChunkTimeInterval}::bigint);");
+                    setChunkTimeInterval.Append($"{operation.ChunkTimeInterval}::bigint");
                 }
                 else
                 {
                     // If it's a string like '7 days', wrap it in quotes.
-                    statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, INTERVAL '{operation.ChunkTimeInterval}');");
+                    setChunkTimeInterval.Append($"INTERVAL '{operation.ChunkTimeInterval}'");
                 }
+                
+                setChunkTimeInterval.Append(");");
+                statements.Add(setChunkTimeInterval.ToString());
             }
 
-            // Check for EnableCompression change
+            // Check for EnableCompression change (Community Edition only)
             bool newCompressionState = operation.EnableCompression || operation.ChunkSkipColumns != null && operation.ChunkSkipColumns.Any();
             bool oldCompressionState = operation.OldEnableCompression || operation.OldChunkSkipColumns != null && operation.OldChunkSkipColumns.Any();
 
             if (newCompressionState != oldCompressionState)
             {
                 string compressionValue = newCompressionState.ToString().ToLower();
-                statements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {compressionValue});");
+                communityStatements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {compressionValue});");
             }
 
-            // Handle ChunkSkipColumns
+            // Handle ChunkSkipColumns (Community Edition only)
             IReadOnlyList<string> newColumns = operation.ChunkSkipColumns ?? [];
             IReadOnlyList<string> oldColumns = operation.OldChunkSkipColumns ?? [];
             List<string> addedColumns = [.. newColumns.Except(oldColumns)];
 
             if (addedColumns.Count != 0)
             {
-                statements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");
+                communityStatements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");
 
                 foreach (string column in addedColumns)
                 {
-                    statements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");
+                    communityStatements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");
                 }
             }
 
@@ -141,7 +157,7 @@ public List<string> Generate(AlterHypertableOperation operation)
             {
                 foreach (string column in removedColumns)
                 {
-                    statements.Add($"SELECT disable_chunk_skipping({qualifiedTableName}, '{column}');");
+                    communityStatements.Add($"SELECT disable_chunk_skipping({qualifiedTableName}, '{column}');");
                 }
             }
 
@@ -192,8 +208,40 @@ public List<string> Generate(AlterHypertableOperation operation)
                 statements.Add($"-- WARNING: TimescaleDB does not support removing dimensions. The following dimensions cannot be removed: {dimensionList}");
             }
 
+
+            // Add wrapped community statements if any exist
+            if (communityStatements.Count > 0)
+            {
+                statements.Add(WrapCommunityFeatures(communityStatements));
+            }
             return statements;
         }
-    }
-}
 
+        /// <summary>
+        /// Wraps multiple SQL statements in a single license check block to ensure they only run on Community Edition
+        /// </summary>
+        private string WrapCommunityFeatures(List<string> sqlStatements)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("DO $$");
+            sb.AppendLine("DECLARE");
+            sb.AppendLine("    license TEXT;");
+            sb.AppendLine("BEGIN");
+            sb.AppendLine("    license := current_setting('timescaledb.license', true);");
+            sb.AppendLine("    ");
+            sb.AppendLine("    IF license IS NULL OR license != 'apache' THEN");
+            
+            foreach (string sql in sqlStatements)
+            {
+                sb.AppendLine($"        {sql}");
+            }
+            
+            sb.AppendLine("    ELSE");
+            sb.AppendLine("        RAISE WARNING 'Skipping Community Edition features (compression, chunk skipping) - not available in Enterprise Edition';");
+            sb.AppendLine("    END IF;");
+            sb.AppendLine("END $$;");
+            
+            return sb.ToString();
+        }
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using CmdScale.EntityFrameworkCore.TimescaleDB.Abstractions;`
`2`	`2`	`using CmdScale.EntityFrameworkCore.TimescaleDB.Operations;`
	`3`	`+using System.Text;`
`3`	`4`
`4`	`5`	`namespace CmdScale.EntityFrameworkCore.TimescaleDB.Generators`
`5`	`6`	`{`
`@@ -16,54 +17,57 @@ public HypertableOperationGenerator(bool isDesignTime = false)`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`sqlHelper = new SqlBuilderHelper(quoteString);`
`19`		`-`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`public List<string> Generate(CreateHypertableOperation operation)`
`23`	`23`	`{`
`24`	`24`	`string qualifiedTableName = sqlHelper.Regclass(operation.TableName, operation.Schema);`
`25`	`25`	`string qualifiedIdentifier = sqlHelper.QualifiedIdentifier(operation.TableName, operation.Schema);`
`26`	`26`
`27`		`- List<string> statements =`
`28`		`- [`
`29`		`- $"SELECT create_hypertable({qualifiedTableName}, '{operation.TimeColumnName}');"`
`30`		`- ];`
	`27`	`+ List<string> statements = [];`
	`28`	`+ List<string> communityStatements = [];`
`31`	`29`
`32`		`- // ChunkTimeInterval`
	`30`	`+ // Build create_hypertable with chunk_time_interval if provided`
	`31`	`+ var createHypertableCall = new StringBuilder();`
	`32`	`+ createHypertableCall.Append($"SELECT create_hypertable({qualifiedTableName}, '{operation.TimeColumnName}'");`
	`33`	`+`
`33`	`34`	`if (!string.IsNullOrEmpty(operation.ChunkTimeInterval))`
`34`	`35`	`{`
`35`	`36`	`// Check if the interval is a plain number (e.g., for microseconds).`
`36`	`37`	`if (long.TryParse(operation.ChunkTimeInterval, out _))`
`37`	`38`	`{`
`38`	`39`	`// If it's a number, don't wrap it in quotes.`
`39`		`- statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, {operation.ChunkTimeInterval}::bigint);");`
	`40`	`+ createHypertableCall.Append($", chunk_time_interval => {operation.ChunkTimeInterval}::bigint");`
`40`	`41`	`}`
`41`	`42`	`else`
`42`	`43`	`{`
`43`	`44`	`// If it's a string like '7 days', wrap it in quotes.`
`44`		`- statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, INTERVAL '{operation.ChunkTimeInterval}');");`
	`45`	`+ createHypertableCall.Append($", chunk_time_interval => INTERVAL '{operation.ChunkTimeInterval}'");`
`45`	`46`	`}`
`46`	`47`	`}`
	`48`	`+`
	`49`	`+ createHypertableCall.Append(");");`
	`50`	`+ statements.Add(createHypertableCall.ToString());`
`47`	`51`
`48`		`- // EnableCompression`
	`52`	`+ // EnableCompression (Community Edition only)`
`49`	`53`	`if (operation.EnableCompression \|\| operation.ChunkSkipColumns?.Count > 0)`
`50`	`54`	`{`
`51`	`55`	`bool enableCompression = operation.EnableCompression \|\| operation.ChunkSkipColumns != null && operation.ChunkSkipColumns.Count > 0;`
`52`		`- statements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {enableCompression.ToString().ToLower()});");`
	`56`	`+ communityStatements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {enableCompression.ToString().ToLower()});");`
`53`	`57`	`}`
`54`	`58`
`55`		`- // ChunkSkipColumns`
	`59`	`+ // ChunkSkipColumns (Community Edition only)`
`56`	`60`	`if (operation.ChunkSkipColumns != null && operation.ChunkSkipColumns.Count > 0)`
`57`	`61`	`{`
`58`		`- statements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");`
	`62`	`+ communityStatements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");`
`59`	`63`
`60`	`64`	`foreach (string column in operation.ChunkSkipColumns)`
`61`	`65`	`{`
`62`		`- statements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");`
	`66`	`+ communityStatements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");`
`63`	`67`	`}`
`64`	`68`	`}`
`65`	`69`
`66`		`- // AdditionalDimensions`
	`70`	`+ // AdditionalDimensions (Available in both editions)`
`67`	`71`	`if (operation.AdditionalDimensions != null && operation.AdditionalDimensions.Count > 0)`
`68`	`72`	`{`
`69`	`73`	`foreach (Dimension dimension in operation.AdditionalDimensions)`
`@@ -85,6 +89,11 @@ public List<string> Generate(CreateHypertableOperation operation)`
`85`	`89`	`}`
`86`	`90`	`}`
`87`	`91`
	`92`	`+ // Add wrapped community statements if any exist`
	`93`	`+ if (communityStatements.Count > 0)`
	`94`	`+ {`
	`95`	`+ statements.Add(WrapCommunityFeatures(communityStatements));`
	`96`	`+ }`
`88`	`97`	`return statements;`
`89`	`98`	`}`
`90`	`99`
`@@ -94,45 +103,52 @@ public List<string> Generate(AlterHypertableOperation operation)`
`94`	`103`	`string qualifiedIdentifier = sqlHelper.QualifiedIdentifier(operation.TableName, operation.Schema);`
`95`	`104`
`96`	`105`	`List<string> statements = [];`
	`106`	`+ List<string> communityStatements = [];`
`97`	`107`
`98`		`- // Check for ChunkTimeInterval change`
	`108`	`+ // Check for ChunkTimeInterval change (Available in both editions)`
`99`	`109`	`if (operation.ChunkTimeInterval != operation.OldChunkTimeInterval)`
`100`	`110`	`{`
	`111`	`+ var setChunkTimeInterval = new StringBuilder();`
	`112`	`+ setChunkTimeInterval.Append($"SELECT set_chunk_time_interval({qualifiedTableName}, ");`
	`113`	`+`
`101`	`114`	`// Check if the interval is a plain number (e.g., for microseconds).`
`102`	`115`	`if (long.TryParse(operation.ChunkTimeInterval, out _))`
`103`	`116`	`{`
`104`	`117`	`// If it's a number, don't wrap it in quotes.`
`105`		`- statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, {operation.ChunkTimeInterval}::bigint);");`
	`118`	`+ setChunkTimeInterval.Append($"{operation.ChunkTimeInterval}::bigint");`
`106`	`119`	`}`
`107`	`120`	`else`
`108`	`121`	`{`
`109`	`122`	`// If it's a string like '7 days', wrap it in quotes.`
`110`		`- statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, INTERVAL '{operation.ChunkTimeInterval}');");`
	`123`	`+ setChunkTimeInterval.Append($"INTERVAL '{operation.ChunkTimeInterval}'");`
`111`	`124`	`}`
	`125`	`+`
	`126`	`+ setChunkTimeInterval.Append(");");`
	`127`	`+ statements.Add(setChunkTimeInterval.ToString());`
`112`	`128`	`}`
`113`	`129`
`114`		`- // Check for EnableCompression change`
	`130`	`+ // Check for EnableCompression change (Community Edition only)`
`115`	`131`	`bool newCompressionState = operation.EnableCompression \|\| operation.ChunkSkipColumns != null && operation.ChunkSkipColumns.Any();`
`116`	`132`	`bool oldCompressionState = operation.OldEnableCompression \|\| operation.OldChunkSkipColumns != null && operation.OldChunkSkipColumns.Any();`
`117`	`133`
`118`	`134`	`if (newCompressionState != oldCompressionState)`
`119`	`135`	`{`
`120`	`136`	`string compressionValue = newCompressionState.ToString().ToLower();`
`121`		`- statements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {compressionValue});");`
	`137`	`+ communityStatements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {compressionValue});");`
`122`	`138`	`}`
`123`	`139`
`124`		`- // Handle ChunkSkipColumns`
	`140`	`+ // Handle ChunkSkipColumns (Community Edition only)`
`125`	`141`	`IReadOnlyList<string> newColumns = operation.ChunkSkipColumns ?? [];`
`126`	`142`	`IReadOnlyList<string> oldColumns = operation.OldChunkSkipColumns ?? [];`
`127`	`143`	`List<string> addedColumns = [.. newColumns.Except(oldColumns)];`
`128`	`144`
`129`	`145`	`if (addedColumns.Count != 0)`
`130`	`146`	`{`
`131`		`- statements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");`
	`147`	`+ communityStatements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");`
`132`	`148`
`133`	`149`	`foreach (string column in addedColumns)`
`134`	`150`	`{`
`135`		`- statements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");`
	`151`	`+ communityStatements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");`
`136`	`152`	`}`
`137`	`153`	`}`
`138`	`154`
`@@ -141,7 +157,7 @@ public List<string> Generate(AlterHypertableOperation operation)`
`141`	`157`	`{`
`142`	`158`	`foreach (string column in removedColumns)`
`143`	`159`	`{`
`144`		`- statements.Add($"SELECT disable_chunk_skipping({qualifiedTableName}, '{column}');");`
	`160`	`+ communityStatements.Add($"SELECT disable_chunk_skipping({qualifiedTableName}, '{column}');");`
`145`	`161`	`}`
`146`	`162`	`}`
`147`	`163`
`@@ -192,8 +208,40 @@ public List<string> Generate(AlterHypertableOperation operation)`
`192`	`208`	`statements.Add($"-- WARNING: TimescaleDB does not support removing dimensions. The following dimensions cannot be removed: {dimensionList}");`
`193`	`209`	`}`
`194`	`210`
	`211`	`+`
	`212`	`+ // Add wrapped community statements if any exist`
	`213`	`+ if (communityStatements.Count > 0)`
	`214`	`+ {`
	`215`	`+ statements.Add(WrapCommunityFeatures(communityStatements));`
	`216`	`+ }`
`195`	`217`	`return statements;`
`196`	`218`	`}`
`197`		`- }`
`198`		`-}`
`199`	`219`
	`220`	`+ /// <summary>`
	`221`	`+ /// Wraps multiple SQL statements in a single license check block to ensure they only run on Community Edition`
	`222`	`+ /// </summary>`
	`223`	`+ private string WrapCommunityFeatures(List<string> sqlStatements)`
	`224`	`+ {`
	`225`	`+ var sb = new StringBuilder();`
	`226`	`+ sb.AppendLine("DO $$");`
	`227`	`+ sb.AppendLine("DECLARE");`
	`228`	`+ sb.AppendLine(" license TEXT;");`
	`229`	`+ sb.AppendLine("BEGIN");`
	`230`	`+ sb.AppendLine(" license := current_setting('timescaledb.license', true);");`
	`231`	`+ sb.AppendLine(" ");`
	`232`	`+ sb.AppendLine(" IF license IS NULL OR license != 'apache' THEN");`
	`233`	`+`
	`234`	`+ foreach (string sql in sqlStatements)`
	`235`	`+ {`
	`236`	`+ sb.AppendLine($" {sql}");`
	`237`	`+ }`
	`238`	`+`
	`239`	`+ sb.AppendLine(" ELSE");`
	`240`	`+ sb.AppendLine(" RAISE WARNING 'Skipping Community Edition features (compression, chunk skipping) - not available in Enterprise Edition';");`
	`241`	`+ sb.AppendLine(" END IF;");`
	`242`	`+ sb.AppendLine("END $$;");`
	`243`	`+`
	`244`	`+ return sb.ToString();`
	`245`	`+ }`
	`246`	`+ }`
	`247`	`+}`