Alpakka 7.0.2 - akka.stream.alpakka.slick.javadsl.Slick

final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##: Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def asInstanceOf[T0]: T0

Definition Classes: Any

def clone(): AnyRef

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws(classOf[java.lang.CloneNotSupportedException]) @native()

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: AnyRef): Boolean

Definition Classes: AnyRef → Any

def finalize(): Unit

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws(classOf[java.lang.Throwable])

def flow[T](session: SlickSession, parallelism: Int, toStatement: Function2[T, Connection, PreparedStatement]): Flow[T, Integer, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
parallelism: How many parallel asynchronous streams should be used to send statements to the database. Use a value of 1 for sequential execution.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def flow[T](session: SlickSession, parallelism: Int, toStatement: Function[T, String]): Flow[T, Integer, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
parallelism: How many parallel asynchronous streams should be used to send statements to the database. Use a value of 1 for sequential execution.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def flow[T](session: SlickSession, toStatement: Function2[T, Connection, PreparedStatement]): Flow[T, Integer, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def flow[T](session: SlickSession, toStatement: Function[T, String]): Flow[T, Integer, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def flowWithPassThrough[T, R](session: SlickSession, executionContext: ExecutionContext, parallelism: Int, toStatement: Function2[T, Connection, PreparedStatement], mapper: Function2[T, Integer, R]): Flow[T, R, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, then executes those statements against the specified Slick database and allows to combine the statement result and element into a result type R.

session: The database session to use.
executionContext: ExecutionContext used to run mapper function in. E.g. the dispatcher of the ActorSystem.
parallelism: How many parallel asynchronous streams should be used to send statements to the database. Use a value of 1 for sequential execution.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.
mapper: A function to create a result from the incoming element T and the database statement result.

def flowWithPassThrough[T, R](session: SlickSession, executionContext: ExecutionContext, parallelism: Int, toStatement: Function[T, String], mapper: BiFunction[T, Integer, R]): Flow[T, R, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, then executes those statements against the specified Slick database and allows to combine the statement result and element into a result type R.

session: The database session to use.
executionContext: ExecutionContext used to run mapper function in. E.g. the dispatcher of the ActorSystem.
parallelism: How many parallel asynchronous streams should be used to send statements to the database. Use a value of 1 for sequential execution.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.
mapper: A function to create a result from the incoming element T and the database statement result.

def flowWithPassThrough[T, R](session: SlickSession, executionContext: ExecutionContext, toStatement: Function2[T, Connection, PreparedStatement], mapper: Function2[T, Integer, R]): Flow[T, R, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, then executes those statements against the specified Slick database and allows to combine the statement result and element into a result type R.

session: The database session to use.
executionContext: ExecutionContext used to run mapper function in. E.g. the dispatcher of the ActorSystem.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.
mapper: A function to create a result from the incoming element T and the database statement result.

def flowWithPassThrough[T, R](session: SlickSession, executionContext: ExecutionContext, toStatement: Function[T, String], mapper: BiFunction[T, Integer, R]): Flow[T, R, NotUsed]

Java API: creates a Flow that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, then executes those statements against the specified Slick database and allows to combine the statement result and element into a result type R.

session: The database session to use.
executionContext: ExecutionContext used to run mapper function in. E.g. the dispatcher of the ActorSystem.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.
mapper: A function to create a result from the incoming element T and the database statement result.

final def getClass(): Class[_ <: AnyRef]

Definition Classes: AnyRef → Any
Annotations: @native()

def hashCode(): Int

Definition Classes: AnyRef → Any
Annotations: @native()

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native()

def sink(session: SlickSession, parallelism: Int): Sink[String, CompletionStage[Done]]

Java API: creates a Sink that takes a stream of complete SQL statements (e.g.

Java API: creates a Sink that takes a stream of complete SQL statements (e.g. a stream of Strings) to execute against the specified Slick database.

session: The database session to use.
parallelism: How many parallel asynchronous streams should be used to send statements to the database. Use a value of 1 for sequential execution.

def sink(session: SlickSession): Sink[String, CompletionStage[Done]]

Java API: creates a Sink that takes a stream of complete SQL statements (e.g.

Java API: creates a Sink that takes a stream of complete SQL statements (e.g. a stream of Strings) to execute against the specified Slick database.

session: The database session to use.

def sink[T](session: SlickSession, parallelism: Int, toStatement: Function2[T, Connection, PreparedStatement]): Sink[T, CompletionStage[Done]]

Java API: creates a Sink that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
parallelism: How many parallel asynchronous streams should be used to send statements to the database. Use a value of 1 for sequential execution.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def sink[T](session: SlickSession, parallelism: Int, toStatement: Function[T, String]): Sink[T, CompletionStage[Done]]

Java API: creates a Sink that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
parallelism: How many parallel asynchronous streams should be used to send statements to the database. Use a value of 1 for sequential execution.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def sink[T](session: SlickSession, toStatement: Function2[T, Connection, PreparedStatement]): Sink[T, CompletionStage[Done]]

Java API: creates a Sink that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def sink[T](session: SlickSession, toStatement: Function[T, String]): Sink[T, CompletionStage[Done]]

Java API: creates a Sink that takes a stream of elements of type T, transforms each element to a SQL statement using the specified function, and then executes those statements against the specified Slick database.

session: The database session to use.
toStatement: A function that creates the SQL statement to execute from the current element. Any DML or DDL statement is acceptable.

def source[T](session: SlickSession, query: String, mapper: Function[SlickRow, T]): Source[T, NotUsed]

Java API: creates a Source that performs the specified query against the specified Slick database and streams the results through the specified mapper function to turn database each row element into an instance of T.

session: The database session to use.
query: The query string to execute. There is currently no Java DSL support for parameter substitution so you will have to build the full query statement before passing it in.
mapper: A function that takes an individual result row and transforms it to an instance of T.

final def synchronized[T0](arg0: => T0): T0

Definition Classes: AnyRef

def toString(): String

Definition Classes: AnyRef → Any

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws(classOf[java.lang.InterruptedException])

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws(classOf[java.lang.InterruptedException])

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws(classOf[java.lang.InterruptedException]) @native()

Packages

Slick

object Slick

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

Slick

object Slick

Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Slick