com.pulumi.googlenative.bigquery.v2.kotlin.RoutineArgs.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of pulumi-google-native-kotlin Show documentation
Show all versions of pulumi-google-native-kotlin Show documentation
Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.
The newest version!
@file:Suppress("NAME_SHADOWING", "DEPRECATION")
package com.pulumi.googlenative.bigquery.v2.kotlin
import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.googlenative.bigquery.v2.RoutineArgs.builder
import com.pulumi.googlenative.bigquery.v2.kotlin.enums.RoutineDeterminismLevel
import com.pulumi.googlenative.bigquery.v2.kotlin.enums.RoutineLanguage
import com.pulumi.googlenative.bigquery.v2.kotlin.enums.RoutineRoutineType
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.ArgumentArgs
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.ArgumentArgsBuilder
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.RemoteFunctionOptionsArgs
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.RemoteFunctionOptionsArgsBuilder
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.RoutineReferenceArgs
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.RoutineReferenceArgsBuilder
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.SparkOptionsArgs
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.SparkOptionsArgsBuilder
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.StandardSqlDataTypeArgs
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.StandardSqlDataTypeArgsBuilder
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.StandardSqlTableTypeArgs
import com.pulumi.googlenative.bigquery.v2.kotlin.inputs.StandardSqlTableTypeArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName
/**
* Creates a new routine in the dataset.
* Auto-naming is currently not supported for this resource.
* @property arguments Optional.
* @property datasetId
* @property definitionBody The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: `CREATE FUNCTION JoinLines(x string, y string) as (concat(x, "\n", y))` The definition_body is `concat(x, "\n", y)` (\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: `CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return "\n";\n'` The definition_body is `return "\n";\n` Note that both \n are replaced with linebreaks.
* @property description Optional. The description of the routine, if defined.
* @property determinismLevel Optional. The determinism level of the JavaScript UDF, if defined.
* @property importedLibraries Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
* @property language Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
* @property project
* @property remoteFunctionOptions Optional. Remote function specific options.
* @property returnTableType Optional. Can be set only if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return table type is inferred from definition_body at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.
* @property returnType Optional if language = "SQL"; required otherwise. Cannot be set if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: "FLOAT64"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64.
* @property routineReference Reference describing the ID of this routine.
* @property routineType The type of routine.
* @property sparkOptions Optional. Spark specific options.
* @property strictMode Optional. Can be set for procedures only. If true (default), the definition body will be validated in the creation and the updates of the procedure. For procedures with an argument of ANY TYPE, the definition body validtion is not supported at creation/update time, and thus this field must be set to false explicitly.
*/
public data class RoutineArgs(
public val arguments: Output>? = null,
public val datasetId: Output? = null,
public val definitionBody: Output? = null,
public val description: Output? = null,
public val determinismLevel: Output? = null,
public val importedLibraries: Output>? = null,
public val language: Output? = null,
public val project: Output? = null,
public val remoteFunctionOptions: Output? = null,
public val returnTableType: Output? = null,
public val returnType: Output? = null,
public val routineReference: Output? = null,
public val routineType: Output? = null,
public val sparkOptions: Output? = null,
public val strictMode: Output? = null,
) : ConvertibleToJava {
override fun toJava(): com.pulumi.googlenative.bigquery.v2.RoutineArgs =
com.pulumi.googlenative.bigquery.v2.RoutineArgs.builder()
.arguments(
arguments?.applyValue({ args0 ->
args0.map({ args0 ->
args0.let({ args0 ->
args0.toJava()
})
})
}),
)
.datasetId(datasetId?.applyValue({ args0 -> args0 }))
.definitionBody(definitionBody?.applyValue({ args0 -> args0 }))
.description(description?.applyValue({ args0 -> args0 }))
.determinismLevel(determinismLevel?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.importedLibraries(importedLibraries?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
.language(language?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.project(project?.applyValue({ args0 -> args0 }))
.remoteFunctionOptions(
remoteFunctionOptions?.applyValue({ args0 ->
args0.let({ args0 ->
args0.toJava()
})
}),
)
.returnTableType(returnTableType?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.returnType(returnType?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.routineReference(routineReference?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.routineType(routineType?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.sparkOptions(sparkOptions?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
.strictMode(strictMode?.applyValue({ args0 -> args0 })).build()
}
/**
* Builder for [RoutineArgs].
*/
@PulumiTagMarker
public class RoutineArgsBuilder internal constructor() {
private var arguments: Output>? = null
private var datasetId: Output? = null
private var definitionBody: Output? = null
private var description: Output? = null
private var determinismLevel: Output? = null
private var importedLibraries: Output>? = null
private var language: Output? = null
private var project: Output? = null
private var remoteFunctionOptions: Output? = null
private var returnTableType: Output? = null
private var returnType: Output? = null
private var routineReference: Output? = null
private var routineType: Output? = null
private var sparkOptions: Output? = null
private var strictMode: Output? = null
/**
* @param value Optional.
*/
@JvmName("kdpyxodeprhswmdk")
public suspend fun arguments(`value`: Output>) {
this.arguments = value
}
@JvmName("bmfjbrvavpfwvojr")
public suspend fun arguments(vararg values: Output) {
this.arguments = Output.all(values.asList())
}
/**
* @param values Optional.
*/
@JvmName("tjrqksuowjkedlxy")
public suspend fun arguments(values: List>) {
this.arguments = Output.all(values)
}
/**
* @param value
*/
@JvmName("rtdqwlbmuftsrvga")
public suspend fun datasetId(`value`: Output) {
this.datasetId = value
}
/**
* @param value The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: `CREATE FUNCTION JoinLines(x string, y string) as (concat(x, "\n", y))` The definition_body is `concat(x, "\n", y)` (\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: `CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return "\n";\n'` The definition_body is `return "\n";\n` Note that both \n are replaced with linebreaks.
*/
@JvmName("omqmctplxlulkynj")
public suspend fun definitionBody(`value`: Output) {
this.definitionBody = value
}
/**
* @param value Optional. The description of the routine, if defined.
*/
@JvmName("gljljyeutldhjjtt")
public suspend fun description(`value`: Output) {
this.description = value
}
/**
* @param value Optional. The determinism level of the JavaScript UDF, if defined.
*/
@JvmName("uegpnuiymnxdheyi")
public suspend fun determinismLevel(`value`: Output) {
this.determinismLevel = value
}
/**
* @param value Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
*/
@JvmName("jjrvmybnnarwhgkl")
public suspend fun importedLibraries(`value`: Output>) {
this.importedLibraries = value
}
@JvmName("pqkwhxuiyaxrumqk")
public suspend fun importedLibraries(vararg values: Output) {
this.importedLibraries = Output.all(values.asList())
}
/**
* @param values Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
*/
@JvmName("foapekyfnfpxvusm")
public suspend fun importedLibraries(values: List>) {
this.importedLibraries = Output.all(values)
}
/**
* @param value Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
*/
@JvmName("xxawtrlrtmannumk")
public suspend fun language(`value`: Output) {
this.language = value
}
/**
* @param value
*/
@JvmName("fnnyovrrmawegwqv")
public suspend fun project(`value`: Output) {
this.project = value
}
/**
* @param value Optional. Remote function specific options.
*/
@JvmName("kcccltinsgonjpwl")
public suspend fun remoteFunctionOptions(`value`: Output) {
this.remoteFunctionOptions = value
}
/**
* @param value Optional. Can be set only if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return table type is inferred from definition_body at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.
*/
@JvmName("wbkksnidfpepqjct")
public suspend fun returnTableType(`value`: Output) {
this.returnTableType = value
}
/**
* @param value Optional if language = "SQL"; required otherwise. Cannot be set if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: "FLOAT64"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64.
*/
@JvmName("xrahdvmshmmwfxrw")
public suspend fun returnType(`value`: Output) {
this.returnType = value
}
/**
* @param value Reference describing the ID of this routine.
*/
@JvmName("sijnsdyglaxmuhcg")
public suspend fun routineReference(`value`: Output) {
this.routineReference = value
}
/**
* @param value The type of routine.
*/
@JvmName("xtvepnxhyyfditdu")
public suspend fun routineType(`value`: Output) {
this.routineType = value
}
/**
* @param value Optional. Spark specific options.
*/
@JvmName("awdscigfkswogvyg")
public suspend fun sparkOptions(`value`: Output) {
this.sparkOptions = value
}
/**
* @param value Optional. Can be set for procedures only. If true (default), the definition body will be validated in the creation and the updates of the procedure. For procedures with an argument of ANY TYPE, the definition body validtion is not supported at creation/update time, and thus this field must be set to false explicitly.
*/
@JvmName("kpfpgreetwswbtqx")
public suspend fun strictMode(`value`: Output) {
this.strictMode = value
}
/**
* @param value Optional.
*/
@JvmName("spxqryihyrllyxwq")
public suspend fun arguments(`value`: List?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.arguments = mapped
}
/**
* @param argument Optional.
*/
@JvmName("rgukcuhlxdstsucb")
public suspend fun arguments(argument: List Unit>) {
val toBeMapped = argument.toList().map { ArgumentArgsBuilder().applySuspend { it() }.build() }
val mapped = of(toBeMapped)
this.arguments = mapped
}
/**
* @param argument Optional.
*/
@JvmName("xoxfoiyofhajqdcw")
public suspend fun arguments(vararg argument: suspend ArgumentArgsBuilder.() -> Unit) {
val toBeMapped = argument.toList().map { ArgumentArgsBuilder().applySuspend { it() }.build() }
val mapped = of(toBeMapped)
this.arguments = mapped
}
/**
* @param argument Optional.
*/
@JvmName("wdsqpqutpyblkmwq")
public suspend fun arguments(argument: suspend ArgumentArgsBuilder.() -> Unit) {
val toBeMapped = listOf(ArgumentArgsBuilder().applySuspend { argument() }.build())
val mapped = of(toBeMapped)
this.arguments = mapped
}
/**
* @param values Optional.
*/
@JvmName("jwvisveasrqfvali")
public suspend fun arguments(vararg values: ArgumentArgs) {
val toBeMapped = values.toList()
val mapped = toBeMapped.let({ args0 -> of(args0) })
this.arguments = mapped
}
/**
* @param value
*/
@JvmName("owabisuhhbwiqfvi")
public suspend fun datasetId(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.datasetId = mapped
}
/**
* @param value The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: `CREATE FUNCTION JoinLines(x string, y string) as (concat(x, "\n", y))` The definition_body is `concat(x, "\n", y)` (\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: `CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return "\n";\n'` The definition_body is `return "\n";\n` Note that both \n are replaced with linebreaks.
*/
@JvmName("dgjnlnvjhuvhuvov")
public suspend fun definitionBody(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.definitionBody = mapped
}
/**
* @param value Optional. The description of the routine, if defined.
*/
@JvmName("bxbbvitrffygvacf")
public suspend fun description(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.description = mapped
}
/**
* @param value Optional. The determinism level of the JavaScript UDF, if defined.
*/
@JvmName("klcbtwaotsxtukwx")
public suspend fun determinismLevel(`value`: RoutineDeterminismLevel?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.determinismLevel = mapped
}
/**
* @param value Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
*/
@JvmName("kdixkhannjrflcrq")
public suspend fun importedLibraries(`value`: List?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.importedLibraries = mapped
}
/**
* @param values Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
*/
@JvmName("xaejmghvfrwylcbg")
public suspend fun importedLibraries(vararg values: String) {
val toBeMapped = values.toList()
val mapped = toBeMapped.let({ args0 -> of(args0) })
this.importedLibraries = mapped
}
/**
* @param value Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
*/
@JvmName("mdsuujkjuylqoeec")
public suspend fun language(`value`: RoutineLanguage?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.language = mapped
}
/**
* @param value
*/
@JvmName("pyjrkhswanleyeyi")
public suspend fun project(`value`: String?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.project = mapped
}
/**
* @param value Optional. Remote function specific options.
*/
@JvmName("dpfofdlhmfoaxyet")
public suspend fun remoteFunctionOptions(`value`: RemoteFunctionOptionsArgs?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.remoteFunctionOptions = mapped
}
/**
* @param argument Optional. Remote function specific options.
*/
@JvmName("oyimpajjumwdhlix")
public suspend fun remoteFunctionOptions(argument: suspend RemoteFunctionOptionsArgsBuilder.() -> Unit) {
val toBeMapped = RemoteFunctionOptionsArgsBuilder().applySuspend { argument() }.build()
val mapped = of(toBeMapped)
this.remoteFunctionOptions = mapped
}
/**
* @param value Optional. Can be set only if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return table type is inferred from definition_body at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.
*/
@JvmName("yriibkgdcqvvmspe")
public suspend fun returnTableType(`value`: StandardSqlTableTypeArgs?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.returnTableType = mapped
}
/**
* @param argument Optional. Can be set only if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return table type is inferred from definition_body at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.
*/
@JvmName("rujdionfsuhsxuhi")
public suspend fun returnTableType(argument: suspend StandardSqlTableTypeArgsBuilder.() -> Unit) {
val toBeMapped = StandardSqlTableTypeArgsBuilder().applySuspend { argument() }.build()
val mapped = of(toBeMapped)
this.returnTableType = mapped
}
/**
* @param value Optional if language = "SQL"; required otherwise. Cannot be set if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: "FLOAT64"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64.
*/
@JvmName("vvlqphbheoyvtetm")
public suspend fun returnType(`value`: StandardSqlDataTypeArgs?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.returnType = mapped
}
/**
* @param argument Optional if language = "SQL"; required otherwise. Cannot be set if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: "FLOAT64"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64.
*/
@JvmName("nwysyuqeeumfhyxv")
public suspend fun returnType(argument: suspend StandardSqlDataTypeArgsBuilder.() -> Unit) {
val toBeMapped = StandardSqlDataTypeArgsBuilder().applySuspend { argument() }.build()
val mapped = of(toBeMapped)
this.returnType = mapped
}
/**
* @param value Reference describing the ID of this routine.
*/
@JvmName("eoevsvfshqphcdqs")
public suspend fun routineReference(`value`: RoutineReferenceArgs?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.routineReference = mapped
}
/**
* @param argument Reference describing the ID of this routine.
*/
@JvmName("niojfhihqqsikjyp")
public suspend fun routineReference(argument: suspend RoutineReferenceArgsBuilder.() -> Unit) {
val toBeMapped = RoutineReferenceArgsBuilder().applySuspend { argument() }.build()
val mapped = of(toBeMapped)
this.routineReference = mapped
}
/**
* @param value The type of routine.
*/
@JvmName("hituthoxujjbfkyx")
public suspend fun routineType(`value`: RoutineRoutineType?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.routineType = mapped
}
/**
* @param value Optional. Spark specific options.
*/
@JvmName("ticmijxrgckehdsm")
public suspend fun sparkOptions(`value`: SparkOptionsArgs?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.sparkOptions = mapped
}
/**
* @param argument Optional. Spark specific options.
*/
@JvmName("rysldlgmnkkkpfel")
public suspend fun sparkOptions(argument: suspend SparkOptionsArgsBuilder.() -> Unit) {
val toBeMapped = SparkOptionsArgsBuilder().applySuspend { argument() }.build()
val mapped = of(toBeMapped)
this.sparkOptions = mapped
}
/**
* @param value Optional. Can be set for procedures only. If true (default), the definition body will be validated in the creation and the updates of the procedure. For procedures with an argument of ANY TYPE, the definition body validtion is not supported at creation/update time, and thus this field must be set to false explicitly.
*/
@JvmName("ktbhglassddycyef")
public suspend fun strictMode(`value`: Boolean?) {
val toBeMapped = value
val mapped = toBeMapped?.let({ args0 -> of(args0) })
this.strictMode = mapped
}
internal fun build(): RoutineArgs = RoutineArgs(
arguments = arguments,
datasetId = datasetId,
definitionBody = definitionBody,
description = description,
determinismLevel = determinismLevel,
importedLibraries = importedLibraries,
language = language,
project = project,
remoteFunctionOptions = remoteFunctionOptions,
returnTableType = returnTableType,
returnType = returnType,
routineReference = routineReference,
routineType = routineType,
sparkOptions = sparkOptions,
strictMode = strictMode,
)
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy