src: generator: hypertable: edition support

anton-schieber · anton-schieber · commit 4ab179bb95e0 · 2025-11-24T11:57:14.000+10:00
Add support for the apache and community editions of timescaledb in the
hypertable generator.
diff --git a/CmdScale.EntityFrameworkCore.TimescaleDB/Generators/HypertableOperationGenerator.cs b/CmdScale.EntityFrameworkCore.TimescaleDB/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)
@@ -79,6 +83,11 @@ public List<string> Generate(CreateHypertableOperation operation)
                 }
             }
 
+            // Add wrapped community statements if any exist
+            if (communityStatements.Count > 0)
+            {
+                statements.Add(WrapCommunityFeatures(communityStatements));
+            }
             return statements;
         }
 
@@ -88,45 +97,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}');");
                 }
             }
 
@@ -135,7 +151,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}');");
                 }
             }
 
@@ -180,8 +196,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)`
`@@ -79,6 +83,11 @@ public List<string> Generate(CreateHypertableOperation operation)`
`79`	`83`	`}`
`80`	`84`	`}`
`81`	`85`
	`86`	`+ // Add wrapped community statements if any exist`
	`87`	`+ if (communityStatements.Count > 0)`
	`88`	`+ {`
	`89`	`+ statements.Add(WrapCommunityFeatures(communityStatements));`
	`90`	`+ }`
`82`	`91`	`return statements;`
`83`	`92`	`}`
`84`	`93`
`@@ -88,45 +97,52 @@ public List<string> Generate(AlterHypertableOperation operation)`
`88`	`97`	`string qualifiedIdentifier = sqlHelper.QualifiedIdentifier(operation.TableName, operation.Schema);`
`89`	`98`
`90`	`99`	`List<string> statements = [];`
	`100`	`+ List<string> communityStatements = [];`
`91`	`101`
`92`		`- // Check for ChunkTimeInterval change`
	`102`	`+ // Check for ChunkTimeInterval change (Available in both editions)`
`93`	`103`	`if (operation.ChunkTimeInterval != operation.OldChunkTimeInterval)`
`94`	`104`	`{`
	`105`	`+ var setChunkTimeInterval = new StringBuilder();`
	`106`	`+ setChunkTimeInterval.Append($"SELECT set_chunk_time_interval({qualifiedTableName}, ");`
	`107`	`+`
`95`	`108`	`// Check if the interval is a plain number (e.g., for microseconds).`
`96`	`109`	`if (long.TryParse(operation.ChunkTimeInterval, out _))`
`97`	`110`	`{`
`98`	`111`	`// If it's a number, don't wrap it in quotes.`
`99`		`- statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, {operation.ChunkTimeInterval}::bigint);");`
	`112`	`+ setChunkTimeInterval.Append($"{operation.ChunkTimeInterval}::bigint");`
`100`	`113`	`}`
`101`	`114`	`else`
`102`	`115`	`{`
`103`	`116`	`// If it's a string like '7 days', wrap it in quotes.`
`104`		`- statements.Add($"SELECT set_chunk_time_interval({qualifiedTableName}, INTERVAL '{operation.ChunkTimeInterval}');");`
	`117`	`+ setChunkTimeInterval.Append($"INTERVAL '{operation.ChunkTimeInterval}'");`
`105`	`118`	`}`
	`119`	`+`
	`120`	`+ setChunkTimeInterval.Append(");");`
	`121`	`+ statements.Add(setChunkTimeInterval.ToString());`
`106`	`122`	`}`
`107`	`123`
`108`		`- // Check for EnableCompression change`
	`124`	`+ // Check for EnableCompression change (Community Edition only)`
`109`	`125`	`bool newCompressionState = operation.EnableCompression \|\| operation.ChunkSkipColumns != null && operation.ChunkSkipColumns.Any();`
`110`	`126`	`bool oldCompressionState = operation.OldEnableCompression \|\| operation.OldChunkSkipColumns != null && operation.OldChunkSkipColumns.Any();`
`111`	`127`
`112`	`128`	`if (newCompressionState != oldCompressionState)`
`113`	`129`	`{`
`114`	`130`	`string compressionValue = newCompressionState.ToString().ToLower();`
`115`		`- statements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {compressionValue});");`
	`131`	`+ communityStatements.Add($"ALTER TABLE {qualifiedIdentifier} SET (timescaledb.compress = {compressionValue});");`
`116`	`132`	`}`
`117`	`133`
`118`		`- // Handle ChunkSkipColumns`
	`134`	`+ // Handle ChunkSkipColumns (Community Edition only)`
`119`	`135`	`IReadOnlyList<string> newColumns = operation.ChunkSkipColumns ?? [];`
`120`	`136`	`IReadOnlyList<string> oldColumns = operation.OldChunkSkipColumns ?? [];`
`121`	`137`	`List<string> addedColumns = [.. newColumns.Except(oldColumns)];`
`122`	`138`
`123`	`139`	`if (addedColumns.Count != 0)`
`124`	`140`	`{`
`125`		`- statements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");`
	`141`	`+ communityStatements.Add("SET timescaledb.enable_chunk_skipping = 'ON';");`
`126`	`142`
`127`	`143`	`foreach (string column in addedColumns)`
`128`	`144`	`{`
`129`		`- statements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");`
	`145`	`+ communityStatements.Add($"SELECT enable_chunk_skipping({qualifiedTableName}, '{column}');");`
`130`	`146`	`}`
`131`	`147`	`}`
`132`	`148`
`@@ -135,7 +151,7 @@ public List<string> Generate(AlterHypertableOperation operation)`
`135`	`151`	`{`
`136`	`152`	`foreach (string column in removedColumns)`
`137`	`153`	`{`
`138`		`- statements.Add($"SELECT disable_chunk_skipping({qualifiedTableName}, '{column}');");`
	`154`	`+ communityStatements.Add($"SELECT disable_chunk_skipping({qualifiedTableName}, '{column}');");`
`139`	`155`	`}`
`140`	`156`	`}`
`141`	`157`
`@@ -180,8 +196,40 @@ public List<string> Generate(AlterHypertableOperation operation)`
`180`	`196`	`statements.Add($"-- WARNING: TimescaleDB does not support removing dimensions. The following dimensions cannot be removed: {dimensionList}");`
`181`	`197`	`}`
`182`	`198`
	`199`	`+`
	`200`	`+ // Add wrapped community statements if any exist`
	`201`	`+ if (communityStatements.Count > 0)`
	`202`	`+ {`
	`203`	`+ statements.Add(WrapCommunityFeatures(communityStatements));`
	`204`	`+ }`
`183`	`205`	`return statements;`
`184`	`206`	`}`
`185`		`- }`
`186`		`-}`
`187`	`207`
	`208`	`+ /// <summary>`
	`209`	`+ /// Wraps multiple SQL statements in a single license check block to ensure they only run on Community Edition`
	`210`	`+ /// </summary>`
	`211`	`+ private string WrapCommunityFeatures(List<string> sqlStatements)`
	`212`	`+ {`
	`213`	`+ var sb = new StringBuilder();`
	`214`	`+ sb.AppendLine("DO $$");`
	`215`	`+ sb.AppendLine("DECLARE");`
	`216`	`+ sb.AppendLine(" license TEXT;");`
	`217`	`+ sb.AppendLine("BEGIN");`
	`218`	`+ sb.AppendLine(" license := current_setting('timescaledb.license', true);");`
	`219`	`+ sb.AppendLine(" ");`
	`220`	`+ sb.AppendLine(" IF license IS NULL OR license != 'apache' THEN");`
	`221`	`+`
	`222`	`+ foreach (string sql in sqlStatements)`
	`223`	`+ {`
	`224`	`+ sb.AppendLine($" {sql}");`
	`225`	`+ }`
	`226`	`+`
	`227`	`+ sb.AppendLine(" ELSE");`
	`228`	`+ sb.AppendLine(" RAISE WARNING 'Skipping Community Edition features (compression, chunk skipping) - not available in Enterprise Edition';");`
	`229`	`+ sb.AppendLine(" END IF;");`
	`230`	`+ sb.AppendLine("END $$;");`
	`231`	`+`
	`232`	`+ return sb.ToString();`
	`233`	`+ }`
	`234`	`+ }`
	`235`	`+}`