text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
package io.getquill.context.jdbc.oracle
import io.getquill.context.sql.base.BatchValuesSpec
import io.getquill._
class BatchValuesJdbcSpec extends BatchValuesSpec {
val context = testContext
import testContext._
override def beforeEach(): Unit = {
testContext.run(query[Product].delete)
testContext.run... | fim | zio/zio-quill | scala |
<|fim_suffix|>ne Record as Filter" in {
testContext.run(
`Ex 3 Inline Record Usage`
) should contain theSameElementsAs `Ex 3 Inline Record Usage expected result`
}
"Example 4 - Ex 4 Mapped Union of Nicknames" in {
println(translate(`Ex 4 Mapped Union of Nicknames`))
testContext.run(
`Ex... | fim | zio/zio-quill | scala |
<|fim_suffix|>sert(p)))
}
()
}
"Example 8 - nested naive" in {
testContext.run(
`Example 8 expertise naive`(lift(`Example 8 param`))
) should contain theSameElementsAs `Example 8 expected result`
}
"Example 9 - nested db" in {
testContext.run(
`Example 9 expertise`(lift(`Exampl... | fim | zio/zio-quill | scala |
<|fim_suffix|>ends DistinctSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testContext.run(query[Couple].delete)
testContext.run(query[Person].delete)
testContext.run(liftQuery(peopleEntries).foreach(p => peopleInsert(p)))
te... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.oracle
import io.getquill.base.Spec
class JdbcContextSpec extends Spec {
<|fim_suffix|> testContext.run(qr1.insertValue(lift(TestEntity("baz", 6, 42L, Some(456), true))))
val updated = testContext.run {
qr1.updateValue(lift(TestEntity("foo", 1, 18L,... | fim | zio/zio-quill | scala |
<|fim_suffix|>tEqual e2.o15
}
}
}
<|fim_prefix|>package io.getquill.context.jdbc.oracle
import io.getquill.context.sql.{EncodingSpec, EncodingTestType}
import io.getquill.Query
import java.time.ZoneId
class JdbcEncodingSpec extends EncodingSpec {
val context = testContext
import testContext._
"encodes ... | fim | zio/zio-quill | scala |
<|fim_suffix|>) should contain theSameElementsAs `Simple OrElse Result`
}
"Example 3 - LeftJoin with FlatMap" in {
testContext.run(`LeftJoin with FlatMap`) should contain theSameElementsAs `LeftJoin with FlatMap Result`
}
"Example 4 - LeftJoin with Flatten" in {
testContext.run(`LeftJoin with Flatten`... | fim | zio/zio-quill | scala |
package io.getquill.context.jdbc.oracle
import io.getquill.context.sql.base.PeopleReturningSpec
class PeopleJdbcReturningSpec extends PeopleReturningSpec {
val context = testContext
import testContext._
override def beforeEach(): Unit = {
testContext.transaction {
testContext.run(query[Contact].dele... | fim | zio/zio-quill | scala |
package io.getquill.context.jdbc.oracle
import io.getquill.Update
import io.getquill.context.sql.base.PeopleSpec
class PeopleJdbcSpec extends PeopleSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testContext.run(sql"alter session set current... | fim | zio/zio-quill | scala |
<|fim_suffix|>aSource.getConnection)(prepareQuery) === List(productEntries.head)
}
"batch" in {
val prepareBatchInsert = prepare(
liftQuery(withOrderedIds(productEntries)).foreach(p => query[Product].insertValue(p))
)
batchInsert(dataSource.getConnection)(prepareBatchInsert).distinct mustEqual L... | fim | zio/zio-quill | scala |
<|fim_suffix|>serted))).head
returnedProduct.description mustEqual "test3"
returnedProduct.sku mustEqual 3L
returnedProduct.id mustEqual inserted
}
"supports casts from string to number" - {
"toInt" in {
case class Product(id: Long, description: String, sku: Int)
val que... | fim | zio/zio-quill | scala |
<|fim_suffix|>inExists)) mustEqual Some(products.map(_.sku).min)
}
"none" in {
await(context.run(minNonExists)) mustBe None
}
}
"max" - {
"some" in {
await(context.run(maxExists)) mustBe Some(products.map(_.sku).max)
}
"none" in {
await(context.run(max... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.oracle
import io.getquill.base.Spec
class ScalarValueSpec extends Spec {
val context = testContext
import testContext._
"Simple Scalar Select" in {
context.run(1) mustEqual 1
}
"Multi Scalar Select" in {
context.run(quote(1 + quote(1))) mustEqual 2
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.<|fim_suffix|>ontext(Literal, "testOracleDB")
with TestEntities
with TestEncoders
with TestDecoders
}
<|fim_middle|>context.jdbc
import io.getquill._
import io.getquill.context.sql.{TestDecoders, TestEncoders}
package object oracle {
object testContext
ext... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import java.sql.Timestamp
import java.time.LocalDate
import java.util.UUID
import io.getquill.context.sql.encoding.ArrayEncodingBaseSpec
import io.getquill.{Literal, PostgresJdbcContext}
class ArrayJdbcEncodingSpec extends ArrayEncodingBaseSpec {
val ctx = te... | fim | zio/zio-quill | scala |
<|fim_suffix|>t mustEqual (expect.toSet)
}
"Ex 2 - Optional Embedded with Renames" in {
import `Ex 2 - Optional Embedded with Renames`._
context.run(insert)
context.run(update, 2)
context.run(get).toSet mustEqual (expect.toSet)
}
"Ex 3 - Deep Embedded Optional" in {
import `Ex 3 - Deep Emb... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.BatchValuesSpec
import io.getquill._
class BatchValuesJdbcSpec extends BatchValuesSpec {
val context = testContext
import testContext._
override def beforeEach(): Unit = {
testContext.run(sql"TRUNCATE TABLE Product... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.CaseClassQuerySpec
import org.scalatest.matchers.should.Matchers._
class CaseClassQueryJdbcSpec extends CaseClassQuerySpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.tra... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import org.scalatest.BeforeAndAfter
import io.getquill.Ord
import io.getquill.base.Spec
class ComplexQuerySpec extends Spec with BeforeAndAfter {
val context = testContext
import testContext._
before {
testContext.run(query[TestEntity].delete)
te... | fim | zio/zio-quill | scala |
<|fim_suffix|> 9 param`))) mustEqual `Example 9 expected result`
}
}
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.DepartmentsSpec
class DepartmentsJdbcSpec extends DepartmentsSpec {
val context = testContext
import testContext._
override def beforeAll = {
t... | fim | zio/zio-quill | scala |
<|fim_suffix|>stContext.transaction {
testContext.run(query[Couple].delete)
testContext.run(query[Person].delete)
testContext.run(liftQuery(peopleEntries).foreach(p => peopleInsert(p)))
testContext.run(liftQuery(couplesEntries).foreach(p => couplesInsert(p)))
}
()
}
"Ex 1 Distinct O... | fim | zio/zio-quill | scala |
package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.ArrayOpsSpec
class JdbcArrayOpsSpec extends ArrayOpsSpec {
val ctx = testContext
import ctx._
"contains" in {
ctx.run(`contains`.`Ex 1 return all`) mustBe `contains`.`Ex 1 expected`
ctx.run(`contains`.`Ex 2 return 1`) mustBe ... | fim | zio/zio-quill | scala |
<|fim_suffix|>enerated(r => query[TestEntity5].filter(_.s == "foo").map(_.i).max)
}.get
id mustBe id2
}
"insert returning" - {
"with multiple columns" in {
ctx.run(qr1.delete)
val inserted = ctx.run {
qr1.insertValue(lift(TestEntity("foo", 1, 18L, Some(123), true))).returning(r => (... | fim | zio/zio-quill | scala |
<|fim_suffix|><- testContext.runIO(query[EncodingTestEntity].delete)
_ <- testContext.runIO(query[EncodingTestEntity].insertValue(lift(e1)))
withoutNull <- testContext.runIO(query[EncodingTestEntity])
_ <- testContext.runIO(query[EncodingTestEntity].delete)
_ ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.OnConflictSpec
class OnConflictJdbcSpec extends OnConflictSpec {
val ctx = testContext
import ctx._
override protected def beforeAll(): Unit = {
ctx.run(qr1.delete)
()
}
"ON CONFLICT DO NOTHING" in {
im... | fim | zio/zio-quill | scala |
<|fim_suffix|>ort org.scalatest.matchers.should.Matchers._
class OptionJdbcSpec extends OptionQuerySpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testContext.run(query[Contact].delete)
testContext.run(query[Address].delete)
testC... | fim | zio/zio-quill | scala |
<|fim_suffix|>ist(result)
}
"2.Ex2 - Not null inner product" in {
context.run(`2.Ex2 - Null inner product insert`)
context.run(data) mustEqual List(`2.Ex2 - Null inner product result`)
}
"2.Ex2 Auto - Not null inner product" in {
val result = `2.Ex2 - Null inner product result`
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.PeopleAggregationSpec
class PeopleJdbcAggregationSpec extends PeopleAggregationSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testContext.run(query[... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.PeopleReturningSpec
class PeopleJdbcReturningSpec extends PeopleReturningSpec {
val context = testContext
import testContext._
override def beforeEach(): Unit = {
testContext.transaction {
testContext.run(que... | fim | zio/zio-quill | scala |
<|fim_suffix|><|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.base.PeopleSpec
class PeopleJdbcSpec extends PeopleSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testContext.run(query[Couple].delete)
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import java.sql.{Connection, ResultSet}
import io.getquill.context.jdbc.PrepareJdbcSpecBase
import org.scalatest.BeforeAndAfter
class PrepareJdbcSpec extends PrepareJdbcSpecBase with BeforeAndAfter {
val context = testContext
import testContext._
before ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.j<|fim_suffix|> |FROM
| Person x""".stripMargin
}
"regular print when not enabled" in {
val q = quote(query[Person])
translate(q) mustEqual "SELECT x.name, x.age FROM Person x"
}
}
<|fim_middle|>dbc.postgres
import io.getquill.base.Spec
import io.getq... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.postgres
import io.getquill.context.sql.ProductSpec
class ProductJdbcSpec extends ProductSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.run(quote(query[Product].delete))
()
}
"Product" - {
"Insert mul... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc
import io.getquill._
import io.getquill.context.sql.{T<|fim_suffix|>res {
object testContext
extends PostgresJdbcContext(Literal, "testPostgresDB")
with TestEntities
with TestEncoders
with TestDecoders
}
<|fim_middle|>estDecoders, TestEncoders}... | fim | zio/zio-quill | scala |
<|fim_suffix|>ach(p => query[Product].insert(_.description -> lift("BlahBlah"), _.sku -> p.sku))
}
testContext.run(op, batchSize)
testContext.run(get).toSet mustEqual result.toSet
}
}
<|fim_prefix|>package io.getquill.context.jdbc.sqlite
import io.getquill.context.sql.base.BatchValuesSpec
import io.getqu... | fim | zio/zio-quill | scala |
<|fim_suffix|> testContext.run(
`Ex 1 CaseClass Record Output`
) should contain theSameElementsAs `Ex 1 CaseClass Record Output expected result`
}
"Example 1A - Single Case Class Mapping" in {
testContext.run(
`Ex 1A CaseClass Record Output`
) should contain theSameElementsAs `Ex 1 CaseClas... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlite
import io.getquill.context.sql.base.DepartmentsSpec
class DepartmentsJdbcSpec extends DepartmentsSpec {
val context = testContext
import testContext._
<|fim_suffix|>t(`Example 8 param`))) mustEqual `Example 8 expected result`
}
"Example 9 - nested db" in... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlite
import io.getquill.context.sql.DistinctSpec
import org.scalatest.matchers.should.Matchers._
class DistinctJdbcSpec extends DistinctSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testCont... | fim | zio/zio-quill | scala |
<|fim_suffix|> }
}
"Insert with returning with single column table" in {
val inserted = testContext.run {
qr4.insertValue(lift(TestEntity4(0))).returningGenerated(_.i)
}
testContext.run(qr4.filter(_.i == lift(inserted))).head.i mustBe inserted
}
}
<|fim_prefix|>package io.getquill.context.jdbc.... | fim | zio/zio-quill | scala |
<|fim_suffix|>ingTestEntity]))
()
}
"Encode/Decode Other Time Types" in {
context.run(query[TimeEntity].delete)
val zid = ZoneId.systemDefault()
val timeEntity = TimeEntity.make(zid)
context.run(query[TimeEntity].insertValue(lift(timeEntity)))
val actual = context.run(query[TimeEntit... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlite
import io.getquill.context.sql.base.OnConflictSpec
class OnConflictJdbcSpec extends OnConflictSpec {
val ctx = testContext
import ctx._
override protected def before<|fim_suffix|>t `onConflictIgnore(_.i)`._
ctx.run(testQuery1) mustEqual res1
ctx.run... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlite
import io.getquill.context.sql.OptionQuerySpec
import org.scalatest.matchers.should.Matchers._
class OptionJdbcSpec extends OptionQuerySpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
test... | fim | zio/zio-quill | scala |
<|fim_suffix|>ningSpec extends PeopleReturningSpec {
val context = testContext
import testContext._
override def beforeEach(): Unit = {
testContext.transaction {
testContext.run(query[Contact].delete)
testContext.run(query[Product].delete)
testContext.run(liftQuery(people).foreach(p => peo... | fim | zio/zio-quill | scala |
<|fim_suffix|>tered update`)
testContext.run(`Ex 11 filtered update get`) must contain theSameElementsAs `Ex 11 filtered update expected`
}
"Example 12 - filtered update co-related" in {
testContext.run(`Ex 12 filtered update co-related`)
testContext.run(
`Ex 12 filtered update co-related get`
... | fim | zio/zio-quill | scala |
<|fim_suffix|>se
import org.scalatest.BeforeAndAfter
class PrepareJdbcSpec extends PrepareJdbcSpecBase with BeforeAndAfter {
val context = testContext
import testContext._
before {
testContext.run(query[Product].delete)
}
def productExtractor = (rs: ResultSet, conn: Connection) => materializeQueryMeta... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlite
import io.getquill.context.sql.ProductSpec
class ProductJdbcSpec extends ProductSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.run(quote(query[Product].delete))
()
}
"Product" - {
"Insert multi... | fim | zio/zio-quill | scala |
package io.getquill.context.jdbc
import io.getquill.context.sql.{TestDecoders, TestEncoders}
import io.getquill.{Literal, SqliteJdbcContext, TestEntities}
package object sqlite {
object testContext
extends SqliteJdbcContext(Literal, "testSqliteDB")
with TestEntities
with TestEncoders
with T... | fim | zio/zio-quill | scala |
<|fim_suffix|>- Batch Insert Returning`._
val ids = testContext.run(op, batchSize)
ids mustEqual expectedIds
testContext.run(get) mustEqual result
}
"Ex 2B - Batch Insert Returning - whole row" in {
import `Ex 2 - Batch Insert Returning`._
implicit def meta = insertMeta[Product](_.id)
def o... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getqui<|fim_suffix|>t._
override def beforeAll = {
testContext.transaction {
testContext.run(query[Department].delete)
testContext.run(query[Employee].delete)
testContext.run(query[Task].delete)
testContext.run(liftQuery... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getqui<|fim_suffix|>_
class DistinctJdbcSpec extends DistinctSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testContext.run(query[Couple].delete)
testContext.run(query... | fim | zio/zio-quill | scala |
<|fim_suffix|>
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getquill.base.Spec
import io.getquill.{Literal, SqlServerJdbcContext}
class JdbcContextSpec extends Spec {
val ctx = testContext
import ctx._
"probes sqls" in {
val p = ctx.probe("DELETE FROM TestEntity")
}
"run non-bat... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getquill.context.sql.EncodingSpec
import io.getquill.Query
import java.time.ZoneId
class JdbcEncodingSpec extends EncodingSpec {
val context = testContext
import testContext._
"encodes and decodes types" in {
testContext.run(delete)
t... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getquill.context.sql.OptionQuerySpec
import org.scalatest.matchers.should.Matchers._
class OptionJdbcSpec extends OptionQuerySpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
t... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getquill.context.sql.base.PeopleReturningSpec
class PeopleJdbcReturningSpec extends PeopleReturningSpec {
val context = testContext
import testContext._
override def b<|fim_suffix|>un(get).toSet mustEqual result(id.head).toSet
}
"Ex 2 upd... | fim | zio/zio-quill | scala |
<|fim_suffix|>
`Ex 12 filtered update co-related get`
) must contain theSameElementsAs `Ex 12 filtered update co-related expected`
}
}
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getquill.context.sql.base.PeopleSpec
class PeopleJdbcSpec extends PeopleSpec {
val context = testCont... | fim | zio/zio-quill | scala |
<|fim_suffix|>l context = testContext
import testContext._
before {
testContext.run(query[Product].delete)
}
def productExtractor = (rs: ResultSet, conn: Connection) => materializeQueryMeta[Product].extract(rs, conn)
val prepareQuery = prepare(query[Product])
implicit val im = insertMeta[Prod... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.sqlserver
import io.getquill.context.sql.ProductSpec
class ProductJdbcSpec extends ProductSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.run(quote(query[Product].delete))
()
}
"Product" - {
"Insert mu... | fim | zio/zio-quill | scala |
<|fim_suffix|> with TestEncoders
with TestDecoders
}
<|fim_prefix|>package io.getquill<|fim_middle|>.context.jdbc
import io.getquill._
import io.getquill.context.sql.{TestDecoders, TestEncoders}
package object sqlserver {
object testContext
extends SqlServerJdbcContext(Literal, "testSqlServerDB")
... | fim | zio/zio-quill | scala |
package io.getquill
final case class JsonValue[T](value: T) extends AnyVal
final case class JsonbValue[T](value: T) extends AnyVal
<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import com.typesafe.config.Config
import io.getquill.context.jdbc.{H2JdbcTypes, MysqlJdbcTypes, OracleJdbcTypes, PostgresJdbcTypes, SqlServerExecuteOverride, SqlServerJdbcTypes, SqliteJdbcTypes}
import io.getquill.context.sql.idiom.SqlIdiom
import io.getquill.context.json.PostgresJson... | fim | zio/zio-quill | scala |
<|fim_suffix|>ose is usually a recoverable
* failure. In the cases where it happens it occurs as the byproduct of a bad
* state (e.g. failing to close a transaction before closing the connection or
* failing to release a stale connection) which will eventually cause other
* operations (i.e. future reads/wri... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.qzio
import java.sql.{Connection, ResultSet}
/**
* In order to allow a ResultSet to be consumed by an Observable, a ResultSet
* <|fim_suffix|>tate == 1) {
state = 0
cached
} else throw new NoSuchElementException("next on empty iterator");
}
}
<|fim_middle|... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.qzio
import io.getquill.ast.ScalarLift
import io.getquill.context.ZioJdbc._
import io.getquill.context._
import io.getquill.context.jdbc.JdbcContextTypes
import io.getquill.context.sql.idiom.SqlIdiom
import io.getquill.jdbczio.Quill
import io.getquill.{NamingStrategy, ReturnAc... | fim | zio/zio-quill | scala |
<|fim_suffix|>>
stmt.setFetchSize(size)
}
stmt
}
def streamQuery[T](
fetchSize: Option[Int],
sql: String,
prepare: Prepare = identityPrepare,
extractor: Extractor[T] = identityExtractor
)(info: ExecutionInfo, dc: Runner): QCStream[T] = {
def prepareStatement(conn: Connection): P... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.qzio
import io.getquill.NamingStrategy
import io.getquill.context.{ExecutionInfo, ContextVerbPrepare}
import io.getquill.context.ZioJdbc._
import io.getquill.context.sql.idiom.SqlIdiom
import io.getquill.util.ContextLogger
import zio.ZIO
import java.sql.{Connection, PreparedS... | fim | zio/zio-quill | scala |
<|fim_suffix|>ct, N] {
val idiom: OracleDialect = OracleDialect
val dsDelegate = new OracleZioJdbcContext[N](naming)
lazy val ds: DataSource = dataSourceInput
}
object Oracle {
def apply[N <: NamingStrategy](naming: N, ds: DataSource) = new Oracle[N](naming, ds)
def fromNamingStrategy... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.jdbczio
import io.getquill.ast.ScalarLift
import io.getquill.{NamingStrategy, ReturnAction}
import io.getquill.context.{ContextVerbStream, ExecutionInfo, ProtoContext, TranslateOptions}
import io.getquill.context.jdbc.JdbcContextTypes
import io.getquill.context.qzio.{ZioContext, ZioJd... | fim | zio/zio-quill | scala |
<|fim_suffix|>sonEncoder)
implicit final def jsonbEntityDecoder[T: ClassTag](implicit jsonDecoder: JsonDecoder[T]): Decoder[JsonbValue[T]] =
entityDecoder[T, JsonbValue[T]](JsonbValue(_))("jsonb", jsonDecoder)
implicit final val jsonAstEncoder: Encoder[JsonValue[Json]] = astEncoder(_.value.toString(), "json"... | fim | zio/zio-quill | scala |
<|fim_suffix|> val obj = new org.postgresql.util.PGobject()
obj.setType(jsonType)
val jsonString = valueToString(jsonValue)
obj.setValue(jsonString)
row.setObject(index, obj)
}
)
def astDecoder[Wrapper](valueFromString: Json => Wrapper): Decoder[Wrapper] =
decoder {... | fim | zio/zio-quill | scala |
<|fim_suffix|>ll.jdbczio.Quill
trait PeopleZioSpec extends PeopleSpec with ZioSpec {
val context: Quill[_, _]
import context._
val `Ex 11 query` = quote(query[Person])
val `Ex 11 expected` = peopleEntries
}
trait PeopleZioProxySpec extends PeopleSpec with ZioProxySpec {
val context: ZioJdbcContext[_, ... | fim | zio/zio-quill | scala |
<|fim_suffix|> ZIO.attempt(stmt.executeQuery()).acquireReleaseWithAuto { rs =>
ZIO.attempt(ResultSetExtractor(rs, stmt.getConnection, extractor))
}
}
} yield result).onDataSource.runSyncUnsafe()
def extractProducts(prep: QCIO[PreparedStatement])(implicit run... | fim | zio/zio-quill | scala |
<|fim_suffix|> val stmt = conn.prepareStatement("select * from person where name = 'Alex'")
val rs = new ResultSetIterator(stmt.executeQuery(), conn, extractor = (rs, conn) => { rs.getString(1) })
rs.head
}
}
.runSyncUnsafe()
result must equal("Alex")
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.context.Context
// Testing we are passing type params explicitly into JdbcContextBase, otherwise
// this file will fail to compile
trait BaseExtensions {
val context: <|fim_suffix|>Extensions extends BaseExtensions {
override val context: PostgresZioJdbcContex... | fim | zio/zio-quill | scala |
<|fim_suffix|>Sink.collectAll).map(_.toList).provideEnvironment(ZEnvironment(runtime.env)))
.getOrThrow()
}
def collect[T](qzio: ZIO[DataSource, Throwable, T])(implicit runtime: Implicit[DataSource]): T =
Unsafe.unsafe { implicit u =>
zio.Runtime.default.unsafe.run(qzio.provideEnvironment(ZEnvi... | fim | zio/zio-quill | scala |
package io.getquill.examples
import io.getquill._
import io.getquill.jdbczio.Quill
import zio.Console.printLine
import zio._
import java.sql.SQLException
object IdiomaticApp extends ZIOAppDefault {
case class DataService(quill: Quill.Postgres[Literal]) {
import quill._
val people = quote(query[Perso... | fim | zio/zio-quill | scala |
<|fim_suffix|>taSource.fromPrefix("testPostgresDB")
val postgresLive = Quill.Postgres.fromNamingStrategy(Literal)
Unsafe.unsafe { implicit u =>
Runtime.default.unsafe
.run(
(for {
joes <- Application.getPeopleByName("Joe")
_ <- printLine(joes)
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.examples.other
import io.getquill.jdbczio.Quill
import io.getquill.{Literal, PostgresZioJdbcContext}
import zio.{Runtime, Unsafe}
object PlainApp {
object MyPostgresContext extends PostgresZioJdbcContext(Literal)
import MyPostgresContext._
case class Person(name: String, age:... | fim | zio/zio-quill | scala |
<|fim_suffix|>untime, Unsafe}
object PlainAppDataSource {
object MyPostgresContext extends PostgresZioJdbcContext(Literal)
import MyPostgresContext._
case class Person(name: String, age: Int)
def config = JdbcContextConfig(LoadConfig("testPostgresDB")).dataSource
val zioDS = Quill.DataSource.fromDataSour... | fim | zio/zio-quill | scala |
<|fim_suffix|>wable, DataSource] =
ZLayer(ZIO.attempt(hikariDataSource))
def main(args: Array[String]): Unit = {
val people = quote {
query[Person].filter(p => p.name == "Alex")
}
val qzio =
MyPostgresContext
.run(people)
.tap(result => printLine(result.toString))
... | fim | zio/zio-quill | scala |
<|fim_suffix|> _ <- printLine(s"Joes: ${joes}")
} yield ()
}
object DBModel {
case class Person(name: String, age: Int)
}
object DBManager {
import DBModel._
val ctx = new PostgresZioJdbcContext(Literal)
import ctx._
val zioDS: ZLayer[Any, Throwable, DataSource] = Quill.DataSource.fromPrefix("test... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.examples.other
import io.getquill._
import io.ge<|fim_suffix|>_
case class Person(name: String, age: Int)
val zioDS = Quill.DataSource.fromPrefix("testPostgresDB")
override def run = {
val people = quote {
query[Person].filter(p => p.name == "Alex")
}
MyPost... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.examples.other
imp<|fim_suffix|>import MyPostgresContext._
case class Person(name: String, age: Int)
def dataSource = JdbcContextConfig(LoadConfig("testPostgresDB")).dataSource
override def run = {
val people = quote {
query[Person].filter(p => p.name == "Alex")
... | fim | zio/zio-quill | scala |
<|fim_suffix|>layer)
.debug("Results")
.exitCode
}
<|fim_prefix|>package io.getquill.examples.other
import io.getquill._
import io.getquill.jdbczio.Quill
import zio._
import javax.sql.DataSource
case class Person(name: String, age: Int)
object QuillContext extends PostgresZioJdbcContext(SnakeCase) {
v... | fim | zio/zio-quill | scala |
<|fim_suffix|>ends ZIOAppDefault {
object Ctx extends PostgresZioJdbcContext(Literal)
case class Person(name: String, age: Int)
def dataSource = JdbcContextConfig(LoadConfig("testPostgresDB")).dataSource
case class MyQueryService(ds: DataSource) {
import Ctx._
implicit val env = Implicit(ds)
va... | fim | zio/zio-quill | scala |
<|fim_suffix|>tgresContext
.run(people)
.tap(result => printLine(result.toString))
.provide(ZLayer.succeed(ds))
.exitCode
}
}
<|fim_prefix|>package io.getquill.examples.other
import io.getquill._
import io.getquill.util.LoadConfig
import zio.{ZIOAppDefault, ZLayer}
import zio.Console.printLin... | fim | zio/zio-quill | scala |
<|fim_suffix|>un(`Ex 10 page 1 query`).runSyncUnsafe() mustEqual `Ex 10 page 1 expected`
testContext.run(`Ex 10 page 2 query`).runSyncUnsafe() mustEqual `Ex 10 page 2 expected`
}
"Example 11 - streaming" in {
collect(testContext.stream(`Ex 11 query`)) should contain theSameElementsAs `Ex 11 expected`
}
}... | fim | zio/zio-quill | scala |
<|fim_suffix|>ult.toSet mustEqual expect.toSet
output <- testContext.run(get)
} yield (output.toSet mustEqual result.toSet)).runSyncUnsafe()
}
// ignored because not supported
"Ex 4 update.returningMany(query)" ignore {
import `Ex 4 update.returningMany(query)`._
(for {
opResult <- test... | fim | zio/zio-quill | scala |
package io.getquill.h2
import java.sql.{Connection, ResultSet}
import io.getquill.PrepareZioJdbcSpecBase
import io.getquill.context.qzio.ImplicitSyntax.Implicit
import org.scalatest.BeforeAndAfter
class PrepareJdbcSpec extends PrepareZioJdbcSpecBase with BeforeAndAfter {
val context = testContext.underlying
impo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.h2
import io.getquill.ZioSpec
import io.getquill.context.sql.ProductSpec
class ProductJdbcSpec extends ProductSpec with ZioSpec {
val context = testContext
import testContext._
override def beforeAll = {
super.beforeAll()
testContext.run(quote(query[Product].delete))... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.h2
import io.getquill.ZioSpec
import zio.ZIO
class ZioJdbcContextSpec extends ZioSpec {
val context = testContext
import testContext._
"provides transaction support" - {
"success" in {
(for {
_ <- testContext.ru<|fim_suffix|> in {
testContext
.... | fim | zio/zio-quill | scala |
<|fim_suffix|>l.ZioSpec.runLayerUnsafe
import io.getquill.jdbczio.Quill
package object h2 {
val pool = runLayerUnsafe(Quill.DataSource.fromPrefix("testH2DB"))
object testContext extends Quill.H2(Literal, pool) with TestEntities
}
<|fim_prefix|>package io.getquill
<|fim_middle|>
import io.getquil<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.integration
import java.sql.{Connection, ResultSet}
import org.scalatest.matchers.should.Matchers._
import io.getquill._
import io.getquill.context.ZioJdbc._
import io.getquill.context.qzio.ImplicitSyntax.Implicit
/**
* This is a long-running test that will cause a OutOfMemory excep... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.misc
import io.getquill.PeopleZioProxySpec
import io.getquill.context.qzio.ImplicitSyntax._
import zio.ZIO
import javax.sql.DataSource
class ImplicitEnvPatternSpec exten<|fim_suffix|>son].filter(p => p.name == "Bert"))
def coras = testContext.run(query[Person].filter(p => p.nam... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.misc
import io.getquill.PeopleZioProxySpec
import io.getquill.context.ZioJdbc._
import zio.{ZIO, ZLayer}
import javax.sql.DataSource
class OnDataSourceSpec extends PeopleZioProxySpec {
val context = testContext
import testContext._
override def beforeAll = {
super.befor... | fim | zio/zio-quill | scala |
<|fim_suffix|> println(Unsafe.unsafe { implicit u =>
Runtime.default.unsafe.run(exec).getOrThrow()
})
}
"test translate" in {
val q = quote {
query[Person].filter(p => p.name == "Bert")
}
println(testContext.translate(q))
}
}
<|fim_prefix|>package io.getquill.misc
import io.getquill... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.misc
import io.getquill.{PrepareZioJdbcSpecBase, ZioProxySpec}
import org.scalatest.BeforeAndAfter
import java.sql.{Connection, ResultSet}
class PrepareJdbcSpec extends PrepareZioJdbcSpecBase with ZioProxySpec with BeforeAndAfter {
val context = testContext
import context._
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.misc
import io.getquill.ZioProxySpec
import io.getquill.context.ZioJdbc._
import org.scalatest.BeforeAndAfter
import zio.ZEnvironment
class StreamingWithFetchSpec extends ZioProxySpec with BeforeAndAfter {
val context = testContext
import testContext._
case class Person(name:... | fim | zio/zio-quill | scala |
package io.getquill.misc
import io.getquill.ZioProxySpec
import zio.{ZIO, ZLayer}
import io.getquill.context.ZioJdbc._
class ZioJdbcUnderlyingContextSpec extends ZioProxySpec {
val context = testContext.underlying
import testContext._
case class TestEntity(s: String, i: Int, l: Long, o: Option[Int], b: Boolea... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.context.qzio.ImplicitSyntax.Implicit
package object misc {
implicit val poo<|fim_suffix|>it(io.getquill.postgres.pool)
object testContext extends PostgresZioJdbcContext(Literal) with TestEntities
}
<|fim_middle|>l = Implic<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|>sAndValues.toMap
def getIndex(i: Int) = fieldsAndValues(i - 1)._2 // Subtract 1 because DB result sets are 1-indexed
def getField(name: String) = map(name)
}
<|fim_prefix|>package io.getquill.mock
import scala.reflect.ClassTag
import scala.reflect.runtime.{universe => ru}
class Introspection[... | fim | zio/zio-quill | scala |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.