Recommending Source Code Examples Via Api Call Usages And: Fill & Download for Free

I like this readme for the JPMML package:jpmml/jpmml-evaluatorIt has everything you need:Features: what this API/package does, what's good about itPrerequisites: What do I need in order to use it?Installation: If it requires OS specific installation, specify for all supported OS. If it uses maven/gradle/other build tool, specify how the package can be obtained via these build tools.Usage/examples: Simple calls to the API, simple code snippets with examples on how to work with this package/API.Example applications: Where can I get simple apps that use this API/package that I can start with?Documentation: don't specify the entire documentation here, but post links to the API references and other docs.License: which open source license do you use? how can I contact you in case I need a commercial license?How to reach youAdditional things to consider:How can I contribute?Current stable version IDRecommended usageTesting your codeHow to buildLink to the issue tracking app (JIRA, Pivotal-tracker etc.) if you use any.Hope this helps!

Maybe you should try Ktorm.Ktorm is a lightweight and efficient ORM Framework for Kotlin directly based on pure JDBC. It provides strong-typed and flexible SQL DSL and convenient sequence APIs to reduce our duplicated effort on database operations. All the SQLs, of course, are generated automatically. Ktorm is open source under the license of Apache 2.0, and its code can be found on GitHub. Leave your star if it’s helpful to you: vincentlauvlwj/KtormFor more documentation, go to its official site: https://ktorm.liuwj.me.FeaturesNo configuration files, no XML, no third-party dependencies, lightweight, easy to use.Strong typed SQL DSL, exposing low-level bugs at compile time.Flexible queries, fine-grained control over the generated SQLs as you wish.Entity sequence APIs, writing queries via sequence functions such as filter, map, sortedBy, etc., just like using Kotlin’s native collections and sequences.Extensible design, write your own extensions to support more operators, data types, SQL functions, database dialects, etc.Quick StartKtorm was deployed to maven central and jcenter, so you just need to add a dependency to your pom.xml file if you are using maven:<dependency>  <groupId>me.liuwj.ktorm</groupId>  <artifactId>ktorm-core</artifactId>  <version>${ktorm.version}</version> </dependency> Or Gradle:compile "me.liuwj.ktorm:ktorm-core:${ktorm.version}" Firstly, create Kotlin objects to describe your table schemas:object Departments : Table<Nothing>("t_department") {  val id by int("id").primaryKey()  val name by varchar("name")  val location by varchar("location") }  object Employees : Table<Nothing>("t_employee") {  val id by int("id").primaryKey()  val name by varchar("name")  val job by varchar("job")  val managerId by int("manager_id")  val hireDate by date("hire_date")  val salary by long("salary")  val departmentId by int("department_id") } Then, connect to your database and write a simple query:fun main() {  Database.connect("jdbc:mysql://localhost:3306/ktorm", driver = "com.mysql.jdbc.Driver")   for (row in Employees.select()) {  println(row[Employees.name])  } } Now you can run this program, Ktorm will generate a SQL select * from t_employee, selecting all employees in the table and printing their names. You can use the for-each loop because the query object returned by the select function implements the Iterable<T> interface. Any other extension functions on Iterable<T> are also available, eg. map/filter/reduce provided by Kotlin standard lib.SQL DSLLet’s add some filter conditions to the query:val names = Employees  .select(Employees.name)  .where { (Employees.departmentId eq 1) and (Employees.name like "%vince%") }  .map { row -> row[Employees.name] } println(names) Generated SQL:select t_employee.name as t_employee_name  from t_employee  where (t_employee.department_id = ?) and (t_employee.name like ?)  That’s the magic of Kotlin, writing a query with Ktorm is easy and natural, the generated SQL is exactly corresponding to the origin Kotlin code. And moreover, it’s strong-typed, the compiler will check your codes before it runs, and you will be benefited from the IDE’s intelligent sense and code completion.Dynamic query based on conditions:val names = Employees  .select(Employees.name)  .whereWithConditions {  if (someCondition) {  it += Employees.managerId.isNull()  }  if (otherCondition) {  it += Employees.departmentId eq 1  }  }  .map { it.getString(1) } Aggregation:val t = Employees val salaries = t  .select(t.departmentId, avg(t.salary))  .groupBy(t.departmentId)  .having { avg(t.salary) greater 100.0 }  .associate { it.getInt(1) to it.getDouble(2) } Union:Employees  .select(Employees.id)  .unionAll(  Departments.select(Departments.id)  )  .unionAll(  Departments.select(Departments.id)  )  .orderBy(Employees.id.desc()) Joining:data class Names(val name: String, val managerName: String?, val departmentName: String)  val emp = Employees.aliased("emp") val mgr = Employees.aliased("mgr") val dept = Departments.aliased("dept")  val results = emp  .leftJoin(dept, on = emp.departmentId eq dept.id)  .leftJoin(mgr, on = emp.managerId eq mgr.id)  .select(emp.name, mgr.name, dept.name)  .orderBy(emp.id.asc())  .map {  Names(  name = it.getString(1),  managerName = it.getString(2),  departmentName = it.getString(3)  )  } Insert:Employees.insert {  it.name to "jerry"  it.job to "trainee"  it.managerId to 1  it.hireDate to LocalDate.now()  it.salary to 50  it.departmentId to 1 } Update:Employees.update {  it.job to "engineer"  it.managerId to null  it.salary to 100   where {  it.id eq 2  } } Delete:Employees.delete { it.id eq 4 } Refer to detailed documentation for more usages about SQL DSL.Entities and Column BindingIn addition to SQL DSL, entity objects are also supported just like other ORM frameworks do. We need to define entity classes firstly and bind table objects to them. In Ktorm, entity classes are defined as interfaces extending from Entity<E>:interface Department : Entity<Department> {  val id: Int  var name: String  var location: String }  interface Employee : Entity<Employee> {  val id: Int?  var name: String  var job: String  var manager: Employee?  var hireDate: LocalDate  var salary: Long  var department: Department } Modify the table objects above, binding database columns to entity properties:object Departments : Table<Department>("t_department") {  val id by int("id").primaryKey().bindTo { it.id }  val name by varchar("name").bindTo { it.name }  val location by varchar("location").bindTo { it.location } }  object Employees : Table<Employee>("t_employee") {  val id by int("id").primaryKey().bindTo { it.id }  val name by varchar("name").bindTo { it.name }  val job by varchar("job").bindTo { it.job }  val managerId by int("manager_id").bindTo { it.manager.id }  val hireDate by date("hire_date").bindTo { it.hireDate }  val salary by long("salary").bindTo { it.salary }  val departmentId by int("department_id").references(Departments) { it.department } } Naming Strategy: It’s highly recommended to name your entity classes by singular nouns, name table objects by plurals (eg. Employee/Employees, Department/Departments).Now that column bindings are configured, so we can use those convenient extension functions for entities. For example, finding an employee by name:val vince = Employees.findOne { it.name eq "vince" } println(vince) The findOne function accepts a lambda expression, generating a select sql with the condition returned by the lambda, auto left joining the referenced table t_department . Generated SQL:select *  from t_employee  left join t_department _ref0 on t_employee.department_id = _ref0.id  where t_employee.name = ? Some other find* functions:Employees.findAll() Employees.findById(1) Employees.findListByIds(listOf(1)) Employees.findMapByIds(listOf(1)) Employees.findList { it.departmentId eq 1 } Employees.findOne { it.name eq "vince" } Save entities to database:val employee = Employee {  name = "jerry"  job = "trainee"  manager = Employees.findOne { it.name eq "vince" }  hireDate = LocalDate.now()  salary = 50  department = Departments.findOne { it.name eq "tech" } }  Employees.add(employee) Flush property changes in memory to database:val employee = Employees.findById(2) ?: return employee.job = "engineer" employee.salary = 100 employee.flushChanges() Delete a entity from database:val employee = Employees.findById(2) ?: return employee.delete() Detailed usages of entity APIs can be found in the documentation of column binding and entity findings.Entity Sequence APIsIn addition to the find* functions, Ktorm also provides a set of APIs named Entity Sequence, which can be used to obtain entity objects from databases. As the name implies, its style and use pattern are highly similar to the sequence APIs in Kotlin standard lib, as it provides many extension functions with the same names, such as filter, map, reduce, etc.To create an entity sequence, we can call the extension function asSequence on a table object:val sequence = Employees.asSequence() Most of the entity sequence APIs are provided as extension functions, which can be divided into two groups, they are intermediate operations and terminal operations.Intermediate OperationsThese functions don’t execute the internal queries but return new-created sequence objects applying some modifications. For example, the filter function creates a new sequence object with the filter condition given by its parameter. The following code obtains all the employees in department 1 by using filter:val employees = Employees.asSequence().filter { it.departmentId eq 1 }.toList() We can see that the usage is almost the same as kotlin.sequences.Sequence, the only difference is the == in the lambda is replaced by the eq function. The filter function can also be called continuously, as all the filter conditions are combined with the and operator.val employees = Employees  .asSequence()  .filter { it.departmentId eq 1 }  .filter { it.managerId.isNotNull() }  .toList() Generated SQL:select *  from t_employee  left join t_department _ref0 on t_employee.department_id = _ref0.id  where (t_employee.department_id = ?) and (t_employee.manager_id is not null) Use sortedBy or soretdByDescending to sort entities in a sequence:val employees = Employees.asSequence().sortedBy { it.salary }.toList() Use drop and take for pagination:val employees = Employees.asSequence().drop(1).take(1).toList() Terminal OperationsTerminal operations of entity sequences execute the queries right now, then obtain the query results and perform some calculations on them. The for-each loop is a typical terminal operation, and the following code uses it to print all employees in the sequence:for (employee in Employees.asSequence()) {  println(employee) } Generated SQL:select *  from t_employee  left join t_department _ref0 on t_employee.department_id = _ref0.id The toCollection functions (including toList, toSet, etc.) are used to collect all the elements into a collection:val employees = Employees.asSequence().toCollection(ArrayList()) The mapColumns function is used to obtain the results of a column:val names = Employees.asSequenceWithoutReferences().mapColumns { it.name } Additional, if we want to select two or more columns, we can change to mapColumns2 or mapColumns3, then we need to wrap our selected columns by Pair or Triple in the closure, and the function’s return type becomes List<Pair<C1?, C2?>> or List<Triple<C1?, C2?, C3?>>.Employees  .asSequenceWithoutReferences()  .filter { it.departmentId eq 1 }  .mapColumns2 { Pair(it.id, it.name) }  .forEach { (id, name) ->  println("$id:$name")  } Generated SQL:select t_employee.id, t_employee.name from t_employee  where t_employee.department_id = ? Other familiar functions are also supported, such as fold, reduce, forEach, etc. The following code calculates the total salary of all employees:val totalSalary = Employees.asSequence().fold(0L) { acc, employee -> acc + employee.salary } Sequence AggregationThe entity sequence APIs not only allow us to obtain entities from databases just like using kotlin.sequences.Sequence, but they also provide rich support for aggregations, so we can conveniently count the columns, sum them, or calculate their averages, etc.The following code obtains the max salary in department 1:val max = Employees  .asSequenceWithoutReferences()  .filter { it.departmentId eq 1 }  .aggregateColumns { max(it.salary) } Also, if we want to aggregate two or more columns, we can change to aggregateColumns2 or aggregateColumns3, then we need to wrap our aggregate expressions by Pair or Triple in the closure, and the function’s return type becomes Pair<C1?, C2?> or Triple<C1?, C2?, C3?>. The example below obtains the average and the range of salaries in department 1:val (avg, diff) = Employees  .asSequenceWithoutReferences()  .filter { it.departmentId eq 1 }  .aggregateColumns2 { Pair(avg(it.salary), max(it.salary) - min(it.salary)) } Generated SQL:select avg(t_employee.salary), max(t_employee.salary) - min(t_employee.salary)  from t_employee  where t_employee.department_id = ? Ktorm also provides many convenient helper functions implemented based on aggregateColumns, they are count, any, none, all, sumBy, maxBy, minBy, averageBy.The following code obtains the max salary in department 1 using maxBy instead:val max = Employees  .asSequenceWithoutReferences()  .filter { it.departmentId eq 1 }  .maxBy { it.salary } Additionally, grouping aggregations are also supported, we just need to call groupingBy before calling aggregateColumns. The following code obtains the average salaries for each department. Here, the result’s type is Map<Int?, Double?>, in which the keys are departments’ IDs, and the values are the average salaries of the departments.val averageSalaries = Employees  .asSequenceWithoutReferences()  .groupingBy { it.departmentId }  .aggregateColumns { avg(it.salary) } Generated SQL:select t_employee.department_id, avg(t_employee.salary)  from t_employee  group by t_employee.department_id Ktorm also provides many convenient helper functions for grouping aggregations, they are eachCount(To), eachSumBy(To), eachMaxBy(To), eachMinBy(To), eachAverageBy(To). With these functions, we can write the code below to obtain average salaries for each department:val averageSalaries = Employees  .asSequenceWithoutReferences()  .groupingBy { it.departmentId }  .eachAverageBy { it.salary } Other familiar functions are also supported, such as aggregate, fold, reduce, etc. They have the same names as the extension functions of kotlin.collections.Grouping, and the usages are totally the same. The following code calculates the total salaries for each department using fold:val totalSalaries = Employees  .asSequenceWithoutReferences()  .groupingBy { it.departmentId }  .fold(0L) { acc, employee ->   acc + employee.salary   } Detailed usages of entity sequence APIs can be found in the documentation of entity sequence and sequence aggregation.

Hi,i think using an existing solution is by far the simplest way to start building real time apps in PHP or java, and it also saves our time comparing to if we start building it from scratch..so the best way of using a realtime solution in your PHP stack is to use it alongside your traditional web stack and communicate between the two components using web services. below are some cool libraries/servies you wanna take a look at..RatchetRatchet is a PHP 5.3 library for asynchronously serving WebSockets. You need to run the application you build using Ratchet as a daemon and communication between your web stack on Ratchet-based application is recommended to take place over a message queue. In fact, there's an integration tutorial which covers just that.Ratchet also provides a pub/sub abstraction via a WebSocket Application Messaging Protocol implementationwhich should make it easier to get started.WrenchWrench provides the barebones required to create a WebSocket server and provides a nice way ofregistering multiple applications with the same server.Without developers using these technologies they won't be updated and maintained so I would recommend that you try both Ratchet and Wrench out. And, if possible contribute to the projects to encourage growth and improvement - that's one of the great things about open source.Side-by-Side SolutionsSince you'll have a loosely coupled architecture it leaves you free to use a realtime technology written in something other than PHP. And if you want to self-host the realtime part of your application, using another technology alongside your PHP web stack is by far your best option.There are lots of realtime web technologies to choose from but here I'll select a few based on popularity, functionality and ease of use.Socket.IOSocket.IO is the probably the most well known and popular realtime web technology. It's a Node.js library that now has numerous ports for other languages. This means you can run the server implementation on the other supported technology stacks but use the same client libraries (JavaScript, iOS, Android etc.) to connect to it.Due to the uptake of Socket.IO there's a large community backing which can really help development. On the downside, the docs can be a little sketchy. For example, at the time of writing the website docs cover using 0.9.x whereas the github readme covers 1.0. Also, it can be quite difficult to find useful functionality like rooms as it's buried inside the github wiki.Socket.IO has a lower learning curve due to a large community of developers who are happy to help with n00b questions. On top of that, the continued expansion of its market share means it will get even better.See the recent Web & PHP article on Integrating Node.js with PHP for an example of using PHP, memcached/redis and Socket.IO.FayeFaye is a solution which offers a simple pub/sub abstraction and has full fallback support. (Well, actually it follows an upgrade strategy, but it's the same net result.) What all this means is that it will serve most application's needs and will work in 99% of browsers and network envirnments.Another great thing about Faye is that it's available in both Ruby and Node.js flavours, and a lot of thought has gone into securing your realtime application with faye. All this means you've got all the pieces you need to build a production ready realtime web app.SockJSIf you want to work close the barebones of WebSockets on the client, but you also want the benefits of fallback support, then SockJS is a great choice. SockJS provides a "WebSocket emulation JavaScript client" and has servers available in Node.js, Erland, Python/Tornado, Python/Twisted and Java. It also has work-in-progress servers available in Ruby, Perl, Go and Haskell.SignalRSignalR is an open source solution for The Official Microsoft ASP.NET Site which is now an official part of ASP.NET. It provides full connectivity fallback support using a variety of solutions.SignalR is particularly interesting because it offers a simple Persistent Connection API but also a Hubs (http://www.asp.net/signalr/overview/hubs-api/hubs-api-guide-javascript-client)API (http://www.asp.net/signalr/overview/hubs-api/hubs-api-guide-javascript-client) (http://www.asp.net/signalr/overview/hubs-api/hubs-api-guide-javascript-client). The documentation tends strongly towards using Hubs.Hubs offer a way of defining objects on the server and SignalR creates proxy objects in JavaScript which you can interact with from your own application JavaScript. The SignalR docs describe this as:The SignalR Hubs API enables you to make remote procedure calls (RPCs) from a server to connected clients and from clients to the server. In server code, you define methods that can be called by clients, and you call methods that run on the client. In client code, you define methods that can be called from the server, and you call methods that run on the server. SignalR takes care of all of the client-to-server plumbing for you.I think this is a really interesting concept and can really help productivity. But I do think it has the potential of resulting in a lot of network activity as methods are called; server to client and client to server. The fact you are simply interacting with an object may mean you forget each call can equate to at least one message being sent over a network - potentially more. This could result in application lag due to network latency and increased resource usage. So, if you use SignalR Hubs in parallel with your PHP web stack please keep this in mind.Hosted SolutionsHosted services are more popular than ever. They offer a great way to offload a lot of complexity, letting you get on with building feature functionality into your application. So, it's not surprising that using a hosted service along side your PHP stack is an option when adding realtime functionality into your app.I used to work for one such company so it's no surprise that I believe this is the best solution when adding realtime to your PHP application. Here's why:You can still do everything in PHPIt removes the architectural complexities involved in running a realtime solution in parallelYou only need to consider scaling your web application, not your realtime infrastructureYou will be up and running much faster with a hosted service than using a self-hosted oneAs shown in the realtime web tech guide, the types of realtime hosted solution can be broken down into two categories based on the functionality you require; messaging (pub/sub) and synchronisation. I'll first cover the most popular messaging options and then the synchronisation ones.Finally, hosted services tend to provide access to their service in two ways. The first is to use a library within your application client to create a connection to the service. This means that whenever new data is available it can be pushed to the client.In addition, these services also offer web APIs that provide access to functionality such as publishing data through to the connected clients. This last point is core in thinking about how you integrate your PHP backend with the service.PusherPusher is fundamentally a realtime messaging service. What makes Pusher great is its simplicity and ease of use.They offer server and client libraries; server libraries for publishing data and providing helper functionality, such as subscription authentication and querying application state, and client libraries for subscribing to data, requesting authentication, and also publishing data when authenticated. Pusher have consistently championed WebSocket technology, but do offer fallback connectivity solutions.Pusher's docs have all the information you'll need to build a realtime web app. Their developer tools offer an extremely clear debugging tool to quickly spot—and squash—application bugs.PubNubPubNub is a realtime messaging service with the added bonus of also offering native Push Notification support. PubNub have a large number of libraries, covering a multitude of platforms, and all tend to offer both pubsub functionality so you get the same functionality no matter the runtime.Right now PubNub only offer HTTP-based connectivity. So, whilst you get the benefits of reliable connectivity through proxies and firewalls on virtually all browsers, you don't get the benefits offered by WebSocket technology.With the recent introduction of Push Notifications and what looks like a high percentage of their customersbuilding for mobile, PubNub may be the best solution at the moment if realtime on mobile is part of your offering.Infinite scalability with the worldwide leader in realtime cloud messaging!Realtime.co are another realtime messaging service and relatively new on the scene. They are worth a mention for the funding they received alone. This demonstrates that their investors at least believe that realtime functionality is going to be a true game-changer.Infinite scalability with the worldwide leader in realtime cloud messaging! offer WebSocket connectivity with fallback support offer a pub/sub API with associated librariesavailable for multiple languages, but also a language markup called XRTML.FirebaseFirebase are one of the first realtime services that I know of to tout themselves as a BaaS, or Backend as a Service platform. (This trend is continuing—check out nobackend.org.) What this means is that it's possible to build an application without any backend, but that doesn't mean it's a requirement.Firebase offer a REST API for publishing and retrieving data along with client libraries for JavaScript, Android and iOS. Since a key part of synchronisation services such as Firebase is persistence, their client libraries focus on working with data structures and providing ways of manipulating those structures and being informed of any changes that occur.This is arguably a little more difficult to wrap your head around than simple pub/sub, but it is very powerful. Try out their tutorial to see just how easy it is.Firebase's docs are well organised, comprehensive and easy to follow. They also have solid developer tools.SimperiumSimperium are another BaaS who were recently acquired by Automattic—the folks behind WordPress.They use SockJS behind the scenes, and their client APIs offer similar functionality to Firebase. The main difference is that they use a concept called buckets—which are simply unique names—to identify data and not URLs like Firebase. This means you can't access the internal of a data structure as easily as you can with Firebase (i.e. child nodes).Simperium offers an HTTP API for integration with other technology stacks.reference - Building Realtime Web Apps with PHP - entwickler.de