You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by sn...@apache.org on 2015/05/15 17:29:12 UTC
cassandra git commit: Use ecj instead of javassist for UDFs
Repository: cassandra
Updated Branches:
refs/heads/trunk 160e7f294 -> 0282cd550
Use ecj instead of javassist for UDFs
patch by Robert Stupp; reviewed by Carl Yeksigian for CASSANDRA-8241
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/0282cd55
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/0282cd55
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/0282cd55
Branch: refs/heads/trunk
Commit: 0282cd550ca119b7fab1d8c6d8ccc1054c316c03
Parents: 160e7f2
Author: Robert Stupp <sn...@snazy.de>
Authored: Fri May 15 17:28:21 2015 +0200
Committer: Robert Stupp <sn...@snazy.de>
Committed: Fri May 15 17:28:21 2015 +0200
----------------------------------------------------------------------
CHANGES.txt | 1 +
NOTICE.txt | 7 +-
build.xml | 4 +-
lib/ecj-4.4.2.jar | Bin 0 -> 2310271 bytes
lib/javassist-3.18.2-GA.jar | Bin 714524 -> 0 bytes
lib/licenses/ecj-4.4.2.txt | 210 +++++++
lib/licenses/javassist-3.18.2-GA.txt | 202 -------
.../cql3/functions/JavaSourceUDFFactory.java | 555 ++++++++++++++-----
.../cassandra/cql3/functions/JavaSourceUDF.txt | 43 ++
test/unit/org/apache/cassandra/cql3/UFTest.java | 112 ++--
10 files changed, 723 insertions(+), 411 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/CHANGES.txt
----------------------------------------------------------------------
diff --git a/CHANGES.txt b/CHANGES.txt
index 6764096..2fed082 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,4 +1,5 @@
2.2
+ * Use ecj instead of javassist for UDFs
* faster async logback configuration for tests (CASSANDRA-9376)
* Add `smallint` and `tinyint` data types (CASSANDRA-8951)
* Avoid thrift schema creation when native driver is used in stress tool (CASSANDRA-9374)
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/NOTICE.txt
----------------------------------------------------------------------
diff --git a/NOTICE.txt b/NOTICE.txt
index 43d4514..a71d822 100644
--- a/NOTICE.txt
+++ b/NOTICE.txt
@@ -61,8 +61,11 @@ Copyright 2010, Cedric Beust cedric@beust.com
HLL++ support provided by stream-lib
(https://github.com/addthis/stream-lib)
-Javassist
-(http://www.csg.ci.i.u-tokyo.ac.jp/~chiba/javassist/)
+Eclipse JDT
+Java compilation software for user-defined-functions is provided by Eclipse,
+which is open source software. The original software and
+related information is available at http://www.eclipse.org/
+(http://www.eclipse.org/jdt/)
SIGAR
http://sigar.hyperic.com/
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/build.xml
----------------------------------------------------------------------
diff --git a/build.xml b/build.xml
index a7c4e98..700c66c 100644
--- a/build.xml
+++ b/build.xml
@@ -384,7 +384,7 @@
<dependency groupId="com.google.code.findbugs" artifactId="jsr305" version="2.0.2" />
<dependency groupId="com.clearspring.analytics" artifactId="stream" version="2.5.2" />
<dependency groupId="com.datastax.cassandra" artifactId="cassandra-driver-core" version="2.1.5" classifier="shaded" />
- <dependency groupId="org.javassist" artifactId="javassist" version="3.18.2-GA" />
+ <dependency groupId="org.eclipse.jdt.core.compiler" artifactId="ecj" version="4.4.2" />
<dependency groupId="org.caffinitas.ohc" artifactId="ohc-core" version="0.3.4" />
<dependency groupId="net.sf.supercsv" artifactId="super-csv" version="2.1.0" />
<dependency groupId="net.ju-n.compile-command-annotations" artifactId="compile-command-annotations" version="1.2.0" />
@@ -436,7 +436,7 @@
<dependency groupId="com.google.code.findbugs" artifactId="jsr305"/>
<dependency groupId="org.antlr" artifactId="antlr"/>
<dependency groupId="com.datastax.cassandra" artifactId="cassandra-driver-core" classifier="shaded"/>
- <dependency groupId="org.javassist" artifactId="javassist"/>
+ <dependency groupId="org.eclipse.jdt.core.compiler" artifactId="ecj"/>
<dependency groupId="org.caffinitas.ohc" artifactId="ohc-core"/>
<dependency groupId="org.openjdk.jmh" artifactId="jmh-core"/>
<dependency groupId="org.openjdk.jmh" artifactId="jmh-generator-annprocess"/>
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/lib/ecj-4.4.2.jar
----------------------------------------------------------------------
diff --git a/lib/ecj-4.4.2.jar b/lib/ecj-4.4.2.jar
new file mode 100644
index 0000000..d9411b3
Binary files /dev/null and b/lib/ecj-4.4.2.jar differ
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/lib/javassist-3.18.2-GA.jar
----------------------------------------------------------------------
diff --git a/lib/javassist-3.18.2-GA.jar b/lib/javassist-3.18.2-GA.jar
deleted file mode 100644
index c8761c8..0000000
Binary files a/lib/javassist-3.18.2-GA.jar and /dev/null differ
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/lib/licenses/ecj-4.4.2.txt
----------------------------------------------------------------------
diff --git a/lib/licenses/ecj-4.4.2.txt b/lib/licenses/ecj-4.4.2.txt
new file mode 100644
index 0000000..6965e5e
--- /dev/null
+++ b/lib/licenses/ecj-4.4.2.txt
@@ -0,0 +1,210 @@
+Eclipse Public License - v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC
+LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
+CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation
+distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are
+distributed by that particular Contributor. A Contribution 'originates' from a
+Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to
+the Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free copyright license to
+reproduce, prepare derivative works of, publicly display, publicly perform,
+distribute and sublicense the Contribution of such Contributor, if any, and such
+derivative works, in source code and object code form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants
+Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed
+Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form.
+This patent license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the
+Licensed Patents. The patent license shall not apply to any other combinations
+which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to
+its Contributions set forth herein, no assurances are provided by any
+Contributor that the Program does not infringe the patent or other intellectual
+property rights of any other entity. Each Contributor disclaims any liability to
+Recipient for claims brought by any other entity based on infringement of
+intellectual property rights or otherwise. As a condition to exercising the
+rights and licenses granted hereunder, each Recipient hereby assumes sole
+responsibility to secure any other intellectual property rights needed, if any.
+For example, if a third party patent license is required to allow Recipient to
+distribute the Program, it is Recipient's responsibility to acquire that license
+before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright
+rights in its Contribution, if any, to grant the copyright license set forth in
+this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its
+own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and
+conditions, express and implied, including warranties or conditions of title and
+non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for
+damages, including direct, indirect, special, incidental and consequential
+damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by
+that Contributor alone and not by any other party; and
+
+iv) states that source code for the Program is available from such Contributor,
+and informs licensees how to obtain it in a reasonable manner on or through a
+medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the
+Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if
+any, in a manner that reasonably allows subsequent Recipients to identify the
+originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with
+respect to end users, business partners and the like. While this license is
+intended to facilitate the commercial use of the Program, the Contributor who
+includes the Program in a commercial product offering should do so in a manner
+which does not create potential liability for other Contributors. Therefore, if
+a Contributor includes the Program in a commercial product offering, such
+Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
+every other Contributor ("Indemnified Contributor") against any losses, damages
+and costs (collectively "Losses") arising from claims, lawsuits and other legal
+actions brought by a third party against the Indemnified Contributor to the
+extent caused by the acts or omissions of such Commercial Contributor in
+connection with its distribution of the Program in a commercial product
+offering. The obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In order
+to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor
+to control, and cooperate with the Commercial Contributor in, the defense and
+any related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product
+offering, Product X. That Contributor is then a Commercial Contributor. If that
+Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such
+Commercial Contributor's responsibility alone. Under this section, the
+Commercial Contributor would have to defend claims against the other
+Contributors related to those performance claims and warranties, and if a court
+requires any other Contributor to pay any damages as a result, the Commercial
+Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
+Recipient is solely responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its exercise of
+rights under this Agreement , including but not limited to the risks and costs
+of program errors, compliance with applicable laws, damage to or loss of data,
+programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
+GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable
+law, it shall not affect the validity or enforceability of the remainder of the
+terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such
+provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+(excluding combinations of the Program with other software or hardware)
+infringes such Recipient's patent(s), then such Recipient's rights granted under
+Section 2(b) shall terminate as of the date such litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to
+comply with any of the material terms or conditions of this Agreement and does
+not cure such failure in a reasonable period of time after becoming aware of
+such noncompliance. If all Recipient's rights under this Agreement terminate,
+Recipient agrees to cease use and distribution of the Program as soon as
+reasonably practicable. However, Recipient's obligations under this Agreement
+and any licenses granted by Recipient relating to the Program shall continue and
+survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in
+order to avoid inconsistency the Agreement is copyrighted and may only be
+modified in the following manner. The Agreement Steward reserves the right to
+publish new versions (including revisions) of this Agreement from time to time.
+No one other than the Agreement Steward has the right to modify this Agreement.
+The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation
+may assign the responsibility to serve as the Agreement Steward to a suitable
+separate entity. Each new version of the Agreement will be given a
+distinguishing version number. The Program (including Contributions) may always
+be distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to distribute the Program (including its Contributions)
+under the new version. Except as expressly stated in Sections 2(a) and 2(b)
+above, Recipient receives no rights or licenses to the intellectual property of
+any Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted under
+this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the
+intellectual property laws of the United States of America. No party to this
+Agreement will bring a legal action under this Agreement more than one year
+after the cause of action arose. Each party waives its rights to a jury trial in
+any resulting litigation.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/lib/licenses/javassist-3.18.2-GA.txt
----------------------------------------------------------------------
diff --git a/lib/licenses/javassist-3.18.2-GA.txt b/lib/licenses/javassist-3.18.2-GA.txt
deleted file mode 100644
index d645695..0000000
--- a/lib/licenses/javassist-3.18.2-GA.txt
+++ /dev/null
@@ -1,202 +0,0 @@
-
- Apache License
- Version 2.0, January 2004
- http://www.apache.org/licenses/
-
- TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
- 1. Definitions.
-
- "License" shall mean the terms and conditions for use, reproduction,
- and distribution as defined by Sections 1 through 9 of this document.
-
- "Licensor" shall mean the copyright owner or entity authorized by
- the copyright owner that is granting the License.
-
- "Legal Entity" shall mean the union of the acting entity and all
- other entities that control, are controlled by, or are under common
- control with that entity. For the purposes of this definition,
- "control" means (i) the power, direct or indirect, to cause the
- direction or management of such entity, whether by contract or
- otherwise, or (ii) ownership of fifty percent (50%) or more of the
- outstanding shares, or (iii) beneficial ownership of such entity.
-
- "You" (or "Your") shall mean an individual or Legal Entity
- exercising permissions granted by this License.
-
- "Source" form shall mean the preferred form for making modifications,
- including but not limited to software source code, documentation
- source, and configuration files.
-
- "Object" form shall mean any form resulting from mechanical
- transformation or translation of a Source form, including but
- not limited to compiled object code, generated documentation,
- and conversions to other media types.
-
- "Work" shall mean the work of authorship, whether in Source or
- Object form, made available under the License, as indicated by a
- copyright notice that is included in or attached to the work
- (an example is provided in the Appendix below).
-
- "Derivative Works" shall mean any work, whether in Source or Object
- form, that is based on (or derived from) the Work and for which the
- editorial revisions, annotations, elaborations, or other modifications
- represent, as a whole, an original work of authorship. For the purposes
- of this License, Derivative Works shall not include works that remain
- separable from, or merely link (or bind by name) to the interfaces of,
- the Work and Derivative Works thereof.
-
- "Contribution" shall mean any work of authorship, including
- the original version of the Work and any modifications or additions
- to that Work or Derivative Works thereof, that is intentionally
- submitted to Licensor for inclusion in the Work by the copyright owner
- or by an individual or Legal Entity authorized to submit on behalf of
- the copyright owner. For the purposes of this definition, "submitted"
- means any form of electronic, verbal, or written communication sent
- to the Licensor or its representatives, including but not limited to
- communication on electronic mailing lists, source code control systems,
- and issue tracking systems that are managed by, or on behalf of, the
- Licensor for the purpose of discussing and improving the Work, but
- excluding communication that is conspicuously marked or otherwise
- designated in writing by the copyright owner as "Not a Contribution."
-
- "Contributor" shall mean Licensor and any individual or Legal Entity
- on behalf of whom a Contribution has been received by Licensor and
- subsequently incorporated within the Work.
-
- 2. Grant of Copyright License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- copyright license to reproduce, prepare Derivative Works of,
- publicly display, publicly perform, sublicense, and distribute the
- Work and such Derivative Works in Source or Object form.
-
- 3. Grant of Patent License. Subject to the terms and conditions of
- this License, each Contributor hereby grants to You a perpetual,
- worldwide, non-exclusive, no-charge, royalty-free, irrevocable
- (except as stated in this section) patent license to make, have made,
- use, offer to sell, sell, import, and otherwise transfer the Work,
- where such license applies only to those patent claims licensable
- by such Contributor that are necessarily infringed by their
- Contribution(s) alone or by combination of their Contribution(s)
- with the Work to which such Contribution(s) was submitted. If You
- institute patent litigation against any entity (including a
- cross-claim or counterclaim in a lawsuit) alleging that the Work
- or a Contribution incorporated within the Work constitutes direct
- or contributory patent infringement, then any patent licenses
- granted to You under this License for that Work shall terminate
- as of the date such litigation is filed.
-
- 4. Redistribution. You may reproduce and distribute copies of the
- Work or Derivative Works thereof in any medium, with or without
- modifications, and in Source or Object form, provided that You
- meet the following conditions:
-
- (a) You must give any other recipients of the Work or
- Derivative Works a copy of this License; and
-
- (b) You must cause any modified files to carry prominent notices
- stating that You changed the files; and
-
- (c) You must retain, in the Source form of any Derivative Works
- that You distribute, all copyright, patent, trademark, and
- attribution notices from the Source form of the Work,
- excluding those notices that do not pertain to any part of
- the Derivative Works; and
-
- (d) If the Work includes a "NOTICE" text file as part of its
- distribution, then any Derivative Works that You distribute must
- include a readable copy of the attribution notices contained
- within such NOTICE file, excluding those notices that do not
- pertain to any part of the Derivative Works, in at least one
- of the following places: within a NOTICE text file distributed
- as part of the Derivative Works; within the Source form or
- documentation, if provided along with the Derivative Works; or,
- within a display generated by the Derivative Works, if and
- wherever such third-party notices normally appear. The contents
- of the NOTICE file are for informational purposes only and
- do not modify the License. You may add Your own attribution
- notices within Derivative Works that You distribute, alongside
- or as an addendum to the NOTICE text from the Work, provided
- that such additional attribution notices cannot be construed
- as modifying the License.
-
- You may add Your own copyright statement to Your modifications and
- may provide additional or different license terms and conditions
- for use, reproduction, or distribution of Your modifications, or
- for any such Derivative Works as a whole, provided Your use,
- reproduction, and distribution of the Work otherwise complies with
- the conditions stated in this License.
-
- 5. Submission of Contributions. Unless You explicitly state otherwise,
- any Contribution intentionally submitted for inclusion in the Work
- by You to the Licensor shall be under the terms and conditions of
- this License, without any additional terms or conditions.
- Notwithstanding the above, nothing herein shall supersede or modify
- the terms of any separate license agreement you may have executed
- with Licensor regarding such Contributions.
-
- 6. Trademarks. This License does not grant permission to use the trade
- names, trademarks, service marks, or product names of the Licensor,
- except as required for reasonable and customary use in describing the
- origin of the Work and reproducing the content of the NOTICE file.
-
- 7. Disclaimer of Warranty. Unless required by applicable law or
- agreed to in writing, Licensor provides the Work (and each
- Contributor provides its Contributions) on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
- implied, including, without limitation, any warranties or conditions
- of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
- PARTICULAR PURPOSE. You are solely responsible for determining the
- appropriateness of using or redistributing the Work and assume any
- risks associated with Your exercise of permissions under this License.
-
- 8. Limitation of Liability. In no event and under no legal theory,
- whether in tort (including negligence), contract, or otherwise,
- unless required by applicable law (such as deliberate and grossly
- negligent acts) or agreed to in writing, shall any Contributor be
- liable to You for damages, including any direct, indirect, special,
- incidental, or consequential damages of any character arising as a
- result of this License or out of the use or inability to use the
- Work (including but not limited to damages for loss of goodwill,
- work stoppage, computer failure or malfunction, or any and all
- other commercial damages or losses), even if such Contributor
- has been advised of the possibility of such damages.
-
- 9. Accepting Warranty or Additional Liability. While redistributing
- the Work or Derivative Works thereof, You may choose to offer,
- and charge a fee for, acceptance of support, warranty, indemnity,
- or other liability obligations and/or rights consistent with this
- License. However, in accepting such obligations, You may act only
- on Your own behalf and on Your sole responsibility, not on behalf
- of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability
- incurred by, or claims asserted against, such Contributor by reason
- of your accepting any such warranty or additional liability.
-
- END OF TERMS AND CONDITIONS
-
- APPENDIX: How to apply the Apache License to your work.
-
- To apply the Apache License to your work, attach the following
- boilerplate notice, with the fields enclosed by brackets "[]"
- replaced with your own identifying information. (Don't include
- the brackets!) The text should be enclosed in the appropriate
- comment syntax for the file format. We also recommend that a
- file or class name and description of purpose be included on the
- same "printed page" as the copyright notice for easier
- identification within third-party archives.
-
- Copyright [yyyy] [name of copyright owner]
-
- Licensed under the Apache License, Version 2.0 (the "License");
- you may not use this file except in compliance with the License.
- You may obtain a copy of the License at
-
- http://www.apache.org/licenses/LICENSE-2.0
-
- Unless required by applicable law or agreed to in writing, software
- distributed under the License is distributed on an "AS IS" BASIS,
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- See the License for the specific language governing permissions and
- limitations under the License.
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java b/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java
index eddb2e6..3809bf3 100644
--- a/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java
+++ b/src/java/org/apache/cassandra/cql3/functions/JavaSourceUDFFactory.java
@@ -17,22 +17,41 @@
*/
package org.apache.cassandra.cql3.functions;
-import java.lang.reflect.Constructor;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
+import com.google.common.io.ByteStreams;
+
+import org.apache.cassandra.utils.FBUtilities;
+import org.eclipse.jdt.core.compiler.IProblem;
+import org.eclipse.jdt.internal.compiler.*;
+import org.eclipse.jdt.internal.compiler.Compiler;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
+import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
+import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
+import org.eclipse.jdt.internal.compiler.env.INameEnvironment;
+import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
+import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
+import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
+
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.datastax.driver.core.DataType;
-import javassist.CannotCompileException;
-import javassist.ClassPool;
-import javassist.CtClass;
-import javassist.CtNewConstructor;
-import javassist.CtNewMethod;
-import javassist.NotFoundException;
import org.apache.cassandra.cql3.ColumnIdentifier;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.exceptions.InvalidRequestException;
@@ -42,12 +61,59 @@ import org.apache.cassandra.exceptions.InvalidRequestException;
*/
public final class JavaSourceUDFFactory
{
- private static final String GENERATED_CODE_PACKAGE = "org.apache.cassandra.cql3.udf.gen.";
+ private static final String GENERATED_PACKAGE = "org.apache.cassandra.cql3.udf.gen";
- protected static final Logger logger = LoggerFactory.getLogger(JavaSourceUDFFactory.class);
+ static final Logger logger = LoggerFactory.getLogger(JavaSourceUDFFactory.class);
private static final AtomicInteger classSequence = new AtomicInteger();
+ private static final ClassLoader baseClassLoader = Thread.currentThread().getContextClassLoader();
+ private static final EcjTargetClassLoader targetClassLoader = new EcjTargetClassLoader();
+ private static final IErrorHandlingPolicy errorHandlingPolicy = DefaultErrorHandlingPolicies.proceedWithAllProblems();
+ private static final IProblemFactory problemFactory = new DefaultProblemFactory(Locale.ENGLISH);
+ private static final CompilerOptions compilerOptions;
+
+ /**
+ * Poor man's template - just a text file splitted at '#' chars.
+ * Each string at an even index is a constant string (just copied),
+ * each string at an odd index is an 'instruction'.
+ */
+ private static final String[] javaSourceTemplate;
+
+ static
+ {
+ Map<String, String> settings = new HashMap<>();
+ settings.put(CompilerOptions.OPTION_LineNumberAttribute,
+ CompilerOptions.GENERATE);
+ settings.put(CompilerOptions.OPTION_SourceFileAttribute,
+ CompilerOptions.DISABLED);
+ settings.put(CompilerOptions.OPTION_ReportDeprecation,
+ CompilerOptions.IGNORE);
+ settings.put(CompilerOptions.OPTION_Source,
+ CompilerOptions.VERSION_1_7);
+ settings.put(CompilerOptions.OPTION_TargetPlatform,
+ CompilerOptions.VERSION_1_7);
+
+ compilerOptions = new CompilerOptions(settings);
+ compilerOptions.parseLiteralExpressionsAsConstants = true;
+
+ try (InputStream input = JavaSourceUDFFactory.class.getResource("JavaSourceUDF.txt").openConnection().getInputStream())
+ {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ FBUtilities.copy(input, output, Long.MAX_VALUE);
+ String template = output.toString();
+
+ StringTokenizer st = new StringTokenizer(template, "#");
+ javaSourceTemplate = new String[st.countTokens()];
+ for (int i = 0; st.hasMoreElements(); i++)
+ javaSourceTemplate[i] = st.nextToken();
+ }
+ catch (IOException e)
+ {
+ throw new RuntimeException(e);
+ }
+ }
+
static UDFunction buildUDF(FunctionName name,
List<ColumnIdentifier> argNames,
List<AbstractType<?>> argTypes,
@@ -66,60 +132,135 @@ public final class JavaSourceUDFFactory
String clsName = generateClassName(name);
- String codeCtor = generateConstructor(clsName);
+ StringBuilder javaSourceBuilder = new StringBuilder();
+ int lineOffset = 1;
+ for (int i = 0; i < javaSourceTemplate.length; i++)
+ {
+ String s = javaSourceTemplate[i];
- // Generate 'execute' method (implements org.apache.cassandra.cql3.functions.Function.execute)
- String codeExec = generateExecuteMethod(argNames, javaParamTypes);
+ // strings at odd indexes are 'instructions'
+ if ((i & 1) == 1)
+ {
+ switch (s)
+ {
+ case "class_name":
+ s = clsName;
+ break;
+ case "body":
+ lineOffset = countNewlines(javaSourceBuilder);
+ s = body;
+ break;
+ case "arguments":
+ s = generateArguments(javaParamTypes, argNames);
+ break;
+ case "argument_list":
+ s = generateArgumentList(javaParamTypes, argNames);
+ break;
+ case "return_type":
+ s = javaSourceName(javaReturnType);
+ break;
+ }
+ }
- // Generate the 'executeInternal' method
- // It is separated to allow return type and argument type checks during compile time via javassist.
- String codeExecInt = generateExecuteInternalMethod(argNames, body, javaReturnType, javaParamTypes);
+ javaSourceBuilder.append(s);
+ }
- logger.debug("Generating java source UDF for {} with following c'tor and functions:\n{}\n{}\n{}",
- name, codeCtor, codeExecInt, codeExec);
+ String targetClassName = GENERATED_PACKAGE + '.' + clsName;
+
+ String javaSource = javaSourceBuilder.toString();
+
+ logger.debug("Compiling Java source UDF '{}' as class '{}' using source:\n{}", name, targetClassName, javaSource);
try
{
- ClassPool classPool = ClassPool.getDefault();
-
- // get super class
- CtClass base = classPool.get(UDFunction.class.getName());
-
- // prepare class to generate
- CtClass cc = classPool.makeClass(GENERATED_CODE_PACKAGE + clsName, base);
- cc.setModifiers(cc.getModifiers() | Modifier.FINAL);
-
- // add c'tor plus methods (order matters)
- cc.addConstructor(CtNewConstructor.make(codeCtor, cc));
- cc.addMethod(CtNewMethod.make(codeExecInt, cc));
- cc.addMethod(CtNewMethod.make(codeExec, cc));
-
- Constructor ctor =
- cc.toClass().getDeclaredConstructor(
- FunctionName.class, List.class, List.class, DataType[].class,
- AbstractType.class, DataType.class,
- String.class);
- return (UDFunction) ctor.newInstance(
- name, argNames, argTypes, argDataTypes,
- returnType, returnDataType,
- body);
- }
- catch (NotFoundException | CannotCompileException | NoSuchMethodException | LinkageError | InstantiationException | IllegalAccessException e)
- {
- throw new InvalidRequestException(String.format("Could not compile function '%s' from Java source: %s", name, e));
+ EcjCompilationUnit compilationUnit = new EcjCompilationUnit(javaSource, targetClassName);
+
+ Compiler compiler = new Compiler(compilationUnit,
+ errorHandlingPolicy,
+ compilerOptions,
+ compilationUnit,
+ problemFactory);
+ compiler.compile(new ICompilationUnit[]{ compilationUnit });
+
+ if (compilationUnit.problemList != null && !compilationUnit.problemList.isEmpty())
+ {
+ boolean fullSource = false;
+ StringBuilder problems = new StringBuilder();
+ for (IProblem problem : compilationUnit.problemList)
+ {
+ long ln = problem.getSourceLineNumber() - lineOffset;
+ if (ln < 1L)
+ {
+ if (problem.isError())
+ {
+ // if generated source around UDF source provided by the user is buggy,
+ // this code is appended.
+ problems.append("GENERATED SOURCE ERROR: line ")
+ .append(problem.getSourceLineNumber())
+ .append(" (in generated source): ")
+ .append(problem.getMessage())
+ .append('\n');
+ fullSource = true;
+ }
+ }
+ else
+ {
+ problems.append("Line ")
+ .append(Long.toString(ln))
+ .append(": ")
+ .append(problem.getMessage())
+ .append('\n');
+ }
+ }
+
+ if (fullSource)
+ throw new InvalidRequestException("Java source compilation failed:\n" + problems + "\n generated source:\n" + javaSource);
+ else
+ throw new InvalidRequestException("Java source compilation failed:\n" + problems);
+ }
+
+ Class cls = targetClassLoader.loadClass(targetClassName);
+
+ if (cls.getDeclaredMethods().length != 2 || cls.getDeclaredConstructors().length != 1)
+ throw new InvalidRequestException("Check your source to not define additional Java methods or constructors");
+ MethodType methodType = MethodType.methodType(void.class)
+ .appendParameterTypes(FunctionName.class, List.class, List.class, DataType[].class,
+ AbstractType.class, DataType.class,
+ String.class);
+ MethodHandle ctor = MethodHandles.lookup().findConstructor(cls, methodType);
+ return (UDFunction) ctor.invokeWithArguments(name, argNames, argTypes, argDataTypes,
+ returnType, returnDataType,
+ body);
}
catch (InvocationTargetException e)
{
// in case of an ITE, use the cause
throw new InvalidRequestException(String.format("Could not compile function '%s' from Java source: %s", name, e.getCause()));
}
+ catch (VirtualMachineError e)
+ {
+ throw e;
+ }
+ catch (Throwable e)
+ {
+ throw new InvalidRequestException(String.format("Could not compile function '%s' from Java source: %s", name, e));
+ }
+ }
+
+ private static int countNewlines(StringBuilder javaSource)
+ {
+ int ln = 0;
+ for (int i = 0; i < javaSource.length(); i++)
+ if (javaSource.charAt(i) == '\n')
+ ln++;
+ return ln;
}
private static String generateClassName(FunctionName name)
{
String qualifiedName = name.toString();
- StringBuilder sb = new StringBuilder(qualifiedName.length()+10);
+ StringBuilder sb = new StringBuilder(qualifiedName.length() + 10);
sb.append('C');
for (int i = 0; i < qualifiedName.length(); i++)
{
@@ -127,130 +268,252 @@ public final class JavaSourceUDFFactory
if (Character.isJavaIdentifierPart(c))
sb.append(c);
}
- sb.append('_');
- sb.append(classSequence.incrementAndGet());
+ sb.append('_')
+ .append(classSequence.incrementAndGet());
return sb.toString();
}
- /**
- * Generates constructor with just a call super class (UDFunction) constructor with constant 'java' as language.
- */
- private static String generateConstructor(String clsName)
+ private static String javaSourceName(Class<?> type)
{
- return "public " + clsName +
- "(org.apache.cassandra.cql3.functions.FunctionName name, " +
- "java.util.List argNames, " +
- "java.util.List argTypes, " +
- "com.datastax.driver.core.DataType[] argDataTypes, " +
- "org.apache.cassandra.db.marshal.AbstractType returnType, " +
- "com.datastax.driver.core.DataType returnDataType, " +
- "String body)\n{" +
- " super(name, argNames, argTypes, argDataTypes, returnType, returnDataType, \"java\", body);\n" +
- "}";
+ String n = type.getName();
+ return n.startsWith("java.lang.") ? type.getSimpleName() : n;
}
- /**
- * Generate executeInternal method (just there to find return and argument type mismatches in UDF body).
- *
- * Generated looks like this:
- * <code><pre>
- * private <JAVA_RETURN_TYPE> executeInternal(<JAVA_ARG_TYPE> paramOne, <JAVA_ARG_TYPE> nextParam)
- * {
- * <UDF_BODY>
- * }
- * </pre></code>
- */
- private static String generateExecuteInternalMethod(List<ColumnIdentifier> argNames, String body, Class<?> returnType, Class<?>[] paramTypes)
+ private static String generateArgumentList(Class<?>[] paramTypes, List<ColumnIdentifier> argNames)
{
// initial builder size can just be a guess (prevent temp object allocations)
- StringBuilder codeInt = new StringBuilder(64 + 32*paramTypes.length + body.length());
- codeInt.append("private ").append(returnType.getName()).append(" executeInternal(");
+ StringBuilder code = new StringBuilder(32 * paramTypes.length);
for (int i = 0; i < paramTypes.length; i++)
{
if (i > 0)
- codeInt.append(", ");
- codeInt.append(paramTypes[i].getName()).
- append(' ').
- append(argNames.get(i));
+ code.append(", ");
+ code.append(javaSourceName(paramTypes[i]))
+ .append(' ')
+ .append(argNames.get(i));
}
- codeInt.append(")\n{").
- append(body).
- append('}');
- return codeInt.toString();
+ return code.toString();
}
- /**
- *
- * Generate public execute() method implementation.
- *
- * Generated looks like this:
- * <code><pre>
- *
- * public java.nio.ByteBuffer execute(int protocolVersion, java.util.List params)
- * throws org.apache.cassandra.exceptions.InvalidRequestException
- * {
- * try
- * {
- * Object result = executeInternal(
- * (<cast to JAVA_ARG_TYPE>)compose(protocolVersion, 0, (java.nio.ByteBuffer)params.get(0)),
- * (<cast to JAVA_ARG_TYPE>)compose(protocolVersion, 1, (java.nio.ByteBuffer)params.get(1)),
- * ...
- * );
- * return decompose(protocolVersion, result);
- * }
- * catch (Throwable t)
- * {
- * logger.debug("Invocation of function '{}' failed", this, t);
- * if (t instanceof VirtualMachineError)
- * throw (VirtualMachineError)t;
- * throw org.apache.cassandra.exceptions.FunctionExecutionException.build(this, t);
- * }
- * }
- * </pre></code>
- */
- private static String generateExecuteMethod(List<ColumnIdentifier> argNames, Class<?>[] paramTypes)
+ private static String generateArguments(Class<?>[] paramTypes, List<ColumnIdentifier> argNames)
{
- // usual methods are 700-800 chars long (prevent temp object allocations)
- StringBuilder code = new StringBuilder(1024);
- // overrides org.apache.cassandra.cql3.functions.Function.execute(java.util.List)
- code.append("public java.nio.ByteBuffer execute(int protocolVersion, java.util.List params)\n" +
- "throws org.apache.cassandra.exceptions.InvalidRequestException\n" +
- "{\n" +
- " try\n" +
- " {\n" +
- " Object result = executeInternal(");
+ StringBuilder code = new StringBuilder(64 * paramTypes.length);
for (int i = 0; i < paramTypes.length; i++)
{
if (i > 0)
- code.append(',');
+ code.append(",\n");
if (logger.isDebugEnabled())
- code.append("\n /* ").append(argNames.get(i)).append(" */ ");
+ code.append(" /* parameter '").append(argNames.get(i)).append("' */\n");
- code.
- // cast to Java type
- append("\n (").append(paramTypes[i].getName()).append(")").
- // generate object representation of input parameter (call UDFunction.compose)
- append("compose(protocolVersion, ").append(i).append(", (java.nio.ByteBuffer)params.get(").append(i).append("))");
+ code
+ // cast to Java type
+ .append(" (").append(javaSourceName(paramTypes[i])).append(") ")
+ // generate object representation of input parameter (call UDFunction.compose)
+ .append("compose(protocolVersion, ").append(i).append(", params.get(").append(i).append("))");
}
+ return code.toString();
+ }
- code.append("\n );\n" +
- // generate serialized return value (returnType is a field in AbstractFunction class), (call UDFunction.decompose)
- " return decompose(protocolVersion, result);\n" +
- //
- // error handling ...
- " }\n" +
- " catch (Throwable t)\n" +
- " {\n" +
- " logger.debug(\"Invocation of function '{}' failed\", this, t);\n" +
- // handle OutOfMemoryError and other fatals not here!
- " if (t instanceof VirtualMachineError)\n" +
- " throw (VirtualMachineError)t;\n" +
- " throw org.apache.cassandra.exceptions.FunctionExecutionException.create(this, t);\n" +
- " }\n" +
- "}");
+ // Java source UDFs are a very simple compilation task, which allows us to let one class implement
+ // all interfaces required by ECJ.
+ static final class EcjCompilationUnit implements ICompilationUnit, ICompilerRequestor, INameEnvironment
+ {
+ List<IProblem> problemList;
+ private final String className;
+ private final char[] sourceCode;
- return code.toString();
+ EcjCompilationUnit(String sourceCode, String className)
+ {
+ this.className = className;
+ this.sourceCode = sourceCode.toCharArray();
+ }
+
+ // ICompilationUnit
+
+ @Override
+ public char[] getFileName()
+ {
+ return sourceCode;
+ }
+
+ @Override
+ public char[] getContents()
+ {
+ return sourceCode;
+ }
+
+ @Override
+ public char[] getMainTypeName()
+ {
+ int dot = className.lastIndexOf('.');
+ return ((dot > 0) ? className.substring(dot + 1) : className).toCharArray();
+ }
+
+ @Override
+ public char[][] getPackageName()
+ {
+ StringTokenizer izer = new StringTokenizer(className, ".");
+ char[][] result = new char[izer.countTokens() - 1][];
+ for (int i = 0; i < result.length; i++)
+ result[i] = izer.nextToken().toCharArray();
+ return result;
+ }
+
+ @Override
+ public boolean ignoreOptionalProblems()
+ {
+ return false;
+ }
+
+ // ICompilerRequestor
+
+ @Override
+ public void acceptResult(CompilationResult result)
+ {
+ if (result.hasErrors())
+ {
+ IProblem[] problems = result.getProblems();
+ if (problemList == null)
+ problemList = new ArrayList<>(problems.length);
+ Collections.addAll(problemList, problems);
+ }
+ else
+ {
+ ClassFile[] classFiles = result.getClassFiles();
+ for (ClassFile classFile : classFiles)
+ targetClassLoader.addClass(className, classFile.getBytes());
+ }
+ }
+
+ // INameEnvironment
+
+ @Override
+ public NameEnvironmentAnswer findType(char[][] compoundTypeName)
+ {
+ StringBuilder result = new StringBuilder();
+ for (int i = 0; i < compoundTypeName.length; i++)
+ {
+ if (i > 0)
+ result.append('.');
+ result.append(compoundTypeName[i]);
+ }
+ return findType(result.toString());
+ }
+
+ @Override
+ public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName)
+ {
+ StringBuilder result = new StringBuilder();
+ int i = 0;
+ for (; i < packageName.length; i++)
+ {
+ if (i > 0)
+ result.append('.');
+ result.append(packageName[i]);
+ }
+ if (i > 0)
+ result.append('.');
+ result.append(typeName);
+ return findType(result.toString());
+ }
+
+ private NameEnvironmentAnswer findType(String className)
+ {
+ if (className.equals(this.className))
+ {
+ return new NameEnvironmentAnswer(this, null);
+ }
+
+ String resourceName = className.replace('.', '/') + ".class";
+
+ try (InputStream is = baseClassLoader.getResourceAsStream(resourceName))
+ {
+ if (is != null)
+ {
+ byte[] classBytes = ByteStreams.toByteArray(is);
+ char[] fileName = className.toCharArray();
+ ClassFileReader classFileReader = new ClassFileReader(classBytes, fileName, true);
+ return new NameEnvironmentAnswer(classFileReader, null);
+ }
+ }
+ catch (IOException | ClassFormatException exc)
+ {
+ throw new RuntimeException(exc);
+ }
+ return null;
+ }
+
+ private boolean isPackage(String result)
+ {
+ if (result.equals(this.className))
+ return false;
+ String resourceName = result.replace('.', '/') + ".class";
+ try (InputStream is = baseClassLoader.getResourceAsStream(resourceName))
+ {
+ return is == null;
+ }
+ catch (IOException e)
+ {
+ // we are here, since close on is failed. That means it was not null
+ return false;
+ }
+ }
+
+ @Override
+ public boolean isPackage(char[][] parentPackageName, char[] packageName)
+ {
+ StringBuilder result = new StringBuilder();
+ int i = 0;
+ if (parentPackageName != null)
+ for (; i < parentPackageName.length; i++)
+ {
+ if (i > 0)
+ result.append('.');
+ result.append(parentPackageName[i]);
+ }
+
+ if (Character.isUpperCase(packageName[0]) && !isPackage(result.toString()))
+ return false;
+ if (i > 0)
+ result.append('.');
+ result.append(packageName);
+
+ return isPackage(result.toString());
+ }
+
+ @Override
+ public void cleanup()
+ {
+ }
}
+ static final class EcjTargetClassLoader extends ClassLoader
+ {
+ // This map is usually empty.
+ // It only contains data *during* UDF compilation but not during runtime.
+ //
+ // addClass() is invoked by ECJ after successful compilation of the generated Java source.
+ // loadClass(targetClassName) is invoked by buildUDF() after ECJ returned from successful compilation.
+ //
+ private final Map<String, byte[]> classes = new ConcurrentHashMap<>();
+
+ EcjTargetClassLoader()
+ {
+ super(baseClassLoader);
+ }
+
+ public void addClass(String className, byte[] classData)
+ {
+ classes.put(className, classData);
+ }
+
+ protected Class<?> findClass(String name) throws ClassNotFoundException
+ {
+ // remove the class binary - it's only used once - so it's wasting heap
+ byte[] classData = classes.remove(name);
+
+ return classData != null ? defineClass(name, classData, 0, classData.length)
+ : super.findClass(name);
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/src/resources/org/apache/cassandra/cql3/functions/JavaSourceUDF.txt
----------------------------------------------------------------------
diff --git a/src/resources/org/apache/cassandra/cql3/functions/JavaSourceUDF.txt b/src/resources/org/apache/cassandra/cql3/functions/JavaSourceUDF.txt
new file mode 100644
index 0000000..985c8ff
--- /dev/null
+++ b/src/resources/org/apache/cassandra/cql3/functions/JavaSourceUDF.txt
@@ -0,0 +1,43 @@
+package org.apache.cassandra.cql3.udf.gen;
+
+import java.nio.ByteBuffer;
+import java.util.List;
+import com.datastax.driver.core.DataType;
+import org.apache.cassandra.cql3.ColumnIdentifier;
+import org.apache.cassandra.cql3.functions.FunctionName;
+import org.apache.cassandra.cql3.functions.JavaSourceUDFFactory;
+import org.apache.cassandra.db.marshal.AbstractType;
+import org.apache.cassandra.exceptions.FunctionExecutionException;
+import org.apache.cassandra.exceptions.InvalidRequestException;
+
+public final class #class_name# extends org.apache.cassandra.cql3.functions.UDFunction
+{
+ public #class_name#(FunctionName name, List<ColumnIdentifier> argNames, List<AbstractType<?>> argTypes,
+ DataType[] argDataTypes, AbstractType<?> returnType, DataType returnDataType, String body)
+ {
+ super(name, argNames, argTypes, argDataTypes, returnType, returnDataType, "java", body);
+ }
+
+ public ByteBuffer execute(int protocolVersion, List<ByteBuffer> params) throws InvalidRequestException
+ {
+ try
+ {
+ #return_type# result = executeInternal(
+#arguments#
+ );
+ return decompose(protocolVersion, result);
+ }
+ catch (Throwable t)
+ {
+ logger.debug("Invocation of function '{}' failed", this, t);
+ if (t instanceof VirtualMachineError)
+ throw (VirtualMachineError)t;
+ throw FunctionExecutionException.create(this, t);
+ }
+ }
+
+ private #return_type# executeInternal(#argument_list#)
+ {
+#body#
+ }
+}
http://git-wip-us.apache.org/repos/asf/cassandra/blob/0282cd55/test/unit/org/apache/cassandra/cql3/UFTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/UFTest.java b/test/unit/org/apache/cassandra/cql3/UFTest.java
index 42bddf3..c9779b9 100644
--- a/test/unit/org/apache/cassandra/cql3/UFTest.java
+++ b/test/unit/org/apache/cassandra/cql3/UFTest.java
@@ -306,11 +306,11 @@ public class UFTest extends CQLTester
"CREATE FUNCTION %s ( input double ) " +
"RETURNS double " +
"LANGUAGE java " +
- "AS 'return Double.valueOf(Math.sin(input.doubleValue()));'");
+ "AS 'return Math.sin(input);'");
// check we can't recreate the same function
- assertInvalidMessage("already exists", "CREATE FUNCTION " + fSin + " ( input double ) RETURNS double LANGUAGE java AS 'return Double.valueOf(Math.sin(input.doubleValue()));'");
+ assertInvalidMessage("already exists", "CREATE FUNCTION " + fSin + " ( input double ) RETURNS double LANGUAGE java AS 'return Math.sin(input);'");
// but that it doesn't comply with "IF NOT EXISTS"
- execute("CREATE FUNCTION IF NOT EXISTS " + fSin + " ( input double ) RETURNS double LANGUAGE java AS 'return Double.valueOf(Math.sin(input.doubleValue()));'");
+ execute("CREATE FUNCTION IF NOT EXISTS " + fSin + " ( input double ) RETURNS double LANGUAGE java AS 'return Math.sin(input);'");
// Validate that it works as expected
assertRows(execute("SELECT key, " + fSin + "(d) FROM %s"),
@@ -337,7 +337,7 @@ public class UFTest extends CQLTester
"CREATE FUNCTION %s ( input double ) " +
"RETURNS double " +
"LANGUAGE java " +
- "AS 'return Double.valueOf(Math.sin(input.doubleValue()));'");
+ "AS 'return Math.sin(input);'");
assertRows(execute("SELECT key, " + fSin2 + "(d) FROM %s"),
row(1, Math.sin(1d)),
row(2, Math.sin(2d)),
@@ -373,7 +373,7 @@ public class UFTest extends CQLTester
"RETURNS text " +
"LANGUAGE java " +
"AS 'StringBuilder sb = new StringBuilder();\n" +
- " for (int i = 0; i < n.intValue(); i++)\n" +
+ " for (int i = 0; i < n; i++)\n" +
" sb.append(v);\n" +
" return sb.toString();'");
@@ -458,8 +458,7 @@ public class UFTest extends CQLTester
" if (input == null) {\n" +
" return null;\n" +
" }\n" +
- " double v = Math.sin( input.doubleValue() );\n" +
- " return Double.valueOf(v);\n" +
+ " return Math.sin( input );\n" +
"';");
// just check created function
@@ -488,7 +487,7 @@ public class UFTest extends CQLTester
{
createTable("CREATE TABLE %s (key int primary key, val double)");
- String functionBody = "\n return Long.valueOf(1L);\n";
+ String functionBody = "\n return 1L;\n";
String fName = createFunction(KEYSPACE, "",
"CREATE OR REPLACE FUNCTION %s() RETURNS bigint LANGUAGE JAVA\n" +
@@ -521,8 +520,8 @@ public class UFTest extends CQLTester
}
catch (InvalidRequestException e)
{
- Assert.assertTrue(e.getMessage(), e.getMessage().contains("[source error]"));
- Assert.assertTrue(e.getMessage(), e.getMessage().contains("; is missing"));
+ Assert.assertTrue(e.getMessage(), e.getMessage().contains("Java source compilation failed"));
+ Assert.assertTrue(e.getMessage(), e.getMessage().contains("insert \";\" to complete BlockStatements"));
}
try
@@ -535,8 +534,8 @@ public class UFTest extends CQLTester
}
catch (InvalidRequestException e)
{
- Assert.assertTrue(e.getMessage(), e.getMessage().contains("[source error]"));
- Assert.assertTrue(e.getMessage(), e.getMessage().contains("no such field: foobarbaz"));
+ Assert.assertTrue(e.getMessage(), e.getMessage().contains("Java source compilation failed"));
+ Assert.assertTrue(e.getMessage(), e.getMessage().contains("foobarbaz cannot be resolved to a type"));
}
}
@@ -545,7 +544,7 @@ public class UFTest extends CQLTester
{
assertInvalidMessage("system keyspace is not user-modifiable",
"CREATE OR REPLACE FUNCTION jfir(val double) RETURNS double LANGUAGE JAVA\n" +
- "AS 'return Long.valueOf(1L);';");
+ "AS 'return 1L;';");
}
@Test
@@ -570,14 +569,13 @@ public class UFTest extends CQLTester
{
createTable("CREATE TABLE %s (key int primary key, val double)");
- String functionBody = "\n" +
+ String functionBody = '\n' +
" // parameter val is of type java.lang.Double\n" +
" /* return type is of type java.lang.Double */\n" +
" if (val == null) {\n" +
" return null;\n" +
" }\n" +
- " double v = Math.sin( val.doubleValue() );\n" +
- " return Double.valueOf(v);\n";
+ " return Math.sin(val);\n";
String fName = createFunction(KEYSPACE, "double",
"CREATE OR REPLACE FUNCTION %s(val double) " +
@@ -704,14 +702,13 @@ public class UFTest extends CQLTester
{
createTable("CREATE TABLE %s (key int primary key, val double)");
- String functionBody = "\n" +
+ String functionBody = '\n' +
" // parameter val is of type java.lang.Double\n" +
" /* return type is of type java.lang.Double */\n" +
" if (val == null) {\n" +
" return null;\n" +
" }\n" +
- " double v = Math.sin( val.doubleValue() );\n" +
- " return Double.valueOf(v);\n";
+ " return Math.sin( val );\n";
String fName = createFunction(KEYSPACE_PER_TEST, "double",
"CREATE OR REPLACE FUNCTION %s(val double) RETURNS double LANGUAGE JAVA " +
@@ -738,7 +735,7 @@ public class UFTest extends CQLTester
{
createTable("CREATE TABLE %s (key int primary key, val double)");
- String functionBody = "\n" +
+ String functionBody = '\n' +
" throw new RuntimeException(\"oh no!\");\n";
String fName = createFunction(KEYSPACE_PER_TEST, "double",
@@ -763,14 +760,13 @@ public class UFTest extends CQLTester
@Test
public void testJavaDollarQuotedFunction() throws Throwable
{
- String functionBody = "\n" +
+ String functionBody = '\n' +
" // parameter val is of type java.lang.Double\n" +
" /* return type is of type java.lang.Double */\n" +
" if (input == null) {\n" +
" return null;\n" +
" }\n" +
- " double v = Math.sin( input.doubleValue() );\n" +
- " return \"'\" + Double.valueOf(v)+'\\\'';\n";
+ " return \"'\"+Math.sin(input)+'\\\'';\n";
String fName = createFunction(KEYSPACE_PER_TEST, "double",
"CREATE FUNCTION %s( input double ) " +
@@ -825,7 +821,7 @@ public class UFTest extends CQLTester
@Test
public void testComplexNullValues() throws Throwable
{
- String type = KEYSPACE + "." + createType("CREATE TYPE %s (txt text, i int)");
+ String type = KEYSPACE + '.' + createType("CREATE TYPE %s (txt text, i int)");
createTable("CREATE TABLE %s (key int primary key, lst list<double>, st set<text>, mp map<int, boolean>," +
"tup frozen<tuple<double, text, int, boolean>>, udt frozen<" + type + ">)");
@@ -953,11 +949,11 @@ public class UFTest extends CQLTester
{
String tupleTypeDef = "frozen<tuple<double, list<double>, set<text>, map<int, boolean>>>";
- createTable("CREATE TABLE %s (key int primary key, tup " + tupleTypeDef + ")");
+ createTable("CREATE TABLE %s (key int primary key, tup " + tupleTypeDef + ')');
String fTup0 = createFunction(KEYSPACE_PER_TEST, tupleTypeDef,
"CREATE FUNCTION %s( tup " + tupleTypeDef + " ) " +
- "RETURNS " + tupleTypeDef + " " +
+ "RETURNS " + tupleTypeDef + ' ' +
"LANGUAGE java\n" +
"AS $$return " +
" tup;$$;");
@@ -1037,7 +1033,7 @@ public class UFTest extends CQLTester
public void testJavaUserTypeWithUse() throws Throwable
{
String type = createType("CREATE TYPE %s (txt text, i int)");
- createTable("CREATE TABLE %s (key int primary key, udt frozen<" + KEYSPACE + "." + type + ">)");
+ createTable("CREATE TABLE %s (key int primary key, udt frozen<" + KEYSPACE + '.' + type + ">)");
execute("INSERT INTO %s (key, udt) VALUES (1, {txt: 'one', i:1})");
for (int version = Server.VERSION_2; version <= maxProtocolVersion; version++)
@@ -1068,9 +1064,9 @@ public class UFTest extends CQLTester
@Test
public void testJavaUserTypeOtherKeyspace() throws Throwable
{
- String type = KEYSPACE + "." + createType("CREATE TYPE %s (txt text, i int)");
+ String type = KEYSPACE + '.' + createType("CREATE TYPE %s (txt text, i int)");
- String fName = createFunction(KEYSPACE_PER_TEST, "frozen<" + type + ">",
+ String fName = createFunction(KEYSPACE_PER_TEST, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS frozen<" + type + "> " +
"LANGUAGE java " +
@@ -1083,23 +1079,23 @@ public class UFTest extends CQLTester
@Test
public void testJavaUserType() throws Throwable
{
- String type = KEYSPACE + "." + createType("CREATE TYPE %s (txt text, i int)");
+ String type = KEYSPACE + '.' + createType("CREATE TYPE %s (txt text, i int)");
createTable("CREATE TABLE %s (key int primary key, udt frozen<" + type + ">)");
- String fUdt0 = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fUdt0 = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS frozen<" + type + "> " +
"LANGUAGE java " +
"AS $$return " +
" udt;$$;");
- String fUdt1 = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fUdt1 = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS text " +
"LANGUAGE java " +
"AS $$return " +
" udt.getString(\"txt\");$$;");
- String fUdt2 = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fUdt2 = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS int " +
"LANGUAGE java " +
@@ -1134,11 +1130,11 @@ public class UFTest extends CQLTester
@Test
public void testUserTypeDrop() throws Throwable
{
- String type = KEYSPACE + "." + createType("CREATE TYPE %s (txt text, i int)");
+ String type = KEYSPACE + '.' + createType("CREATE TYPE %s (txt text, i int)");
createTable("CREATE TABLE %s (key int primary key, udt frozen<" + type + ">)");
- String fName = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS int " +
"LANGUAGE java " +
@@ -1170,11 +1166,11 @@ public class UFTest extends CQLTester
@Test
public void testJavaUserTypeRenameField() throws Throwable
{
- String type = KEYSPACE + "." + createType("CREATE TYPE %s (txt text, i int)");
+ String type = KEYSPACE + '.' + createType("CREATE TYPE %s (txt text, i int)");
createTable("CREATE TABLE %s (key int primary key, udt frozen<" + type + ">)");
- String fName = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS text LANGUAGE java\n" +
"AS $$return udt.getString(\"txt\");$$;");
@@ -1198,40 +1194,40 @@ public class UFTest extends CQLTester
@Test
public void testJavaUserTypeAddFieldWithReplace() throws Throwable
{
- String type = KEYSPACE + "." + createType("CREATE TYPE %s (txt text, i int)");
+ String type = KEYSPACE + '.' + createType("CREATE TYPE %s (txt text, i int)");
createTable("CREATE TABLE %s (key int primary key, udt frozen<" + type + ">)");
- String fName1replace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName1replace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS text LANGUAGE java\n" +
"AS $$return udt.getString(\"txt\");$$;");
- String fName2replace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName2replace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS int LANGUAGE java\n" +
"AS $$return Integer.valueOf(udt.getInt(\"i\"));$$;");
- String fName3replace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName3replace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS double LANGUAGE java\n" +
"AS $$return Double.valueOf(udt.getDouble(\"added\"));$$;");
- String fName4replace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName4replace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS frozen<" + type + "> LANGUAGE java\n" +
"AS $$return udt;$$;");
- String fName1noReplace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName1noReplace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS text LANGUAGE java\n" +
"AS $$return udt.getString(\"txt\");$$;");
- String fName2noReplace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName2noReplace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS int LANGUAGE java\n" +
"AS $$return Integer.valueOf(udt.getInt(\"i\"));$$;");
- String fName3noReplace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName3noReplace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS double LANGUAGE java\n" +
"AS $$return Double.valueOf(udt.getDouble(\"added\"));$$;");
- String fName4noReplace = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fName4noReplace = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS frozen<" + type + "> LANGUAGE java\n" +
"AS $$return udt;$$;");
@@ -1311,7 +1307,7 @@ public class UFTest extends CQLTester
@Test
public void testJavaUTCollections() throws Throwable
{
- String type = KEYSPACE + "." + createType("CREATE TYPE %s (txt text, i int)");
+ String type = KEYSPACE + '.' + createType("CREATE TYPE %s (txt text, i int)");
createTable(String.format("CREATE TABLE %%s " +
"(key int primary key, lst list<frozen<%s>>, st set<frozen<%s>>, mp map<int, frozen<%s>>)",
@@ -1418,7 +1414,7 @@ public class UFTest extends CQLTester
public void testJavascriptTupleTypeCollection() throws Throwable
{
String tupleTypeDef = "frozen<tuple<double, list<double>, set<text>, map<int, boolean>>>";
- createTable("CREATE TABLE %s (key int primary key, tup " + tupleTypeDef + ")");
+ createTable("CREATE TABLE %s (key int primary key, tup " + tupleTypeDef + ')');
String fTup1 = createFunction(KEYSPACE_PER_TEST, tupleTypeDef,
"CREATE FUNCTION %s( tup " + tupleTypeDef + " ) " +
@@ -1506,19 +1502,19 @@ public class UFTest extends CQLTester
createTable("CREATE TABLE %s (key int primary key, udt frozen<" + type + ">)");
- String fUdt1 = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fUdt1 = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS frozen<" + type + "> " +
"LANGUAGE javascript\n" +
"AS $$" +
" udt;$$;");
- String fUdt2 = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fUdt2 = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS text " +
"LANGUAGE javascript\n" +
"AS $$" +
" udt.getString(\"txt\");$$;");
- String fUdt3 = createFunction(KEYSPACE, "frozen<" + type + ">",
+ String fUdt3 = createFunction(KEYSPACE, "frozen<" + type + '>',
"CREATE FUNCTION %s( udt frozen<" + type + "> ) " +
"RETURNS int " +
"LANGUAGE javascript\n" +
@@ -1594,7 +1590,7 @@ public class UFTest extends CQLTester
{
createTable("CREATE TABLE %s (key int primary key, val double)");
- String functionBody = "\n" +
+ String functionBody = '\n' +
" Math.sin(val);\n";
String fName = createFunction(KEYSPACE, "double",
@@ -1684,8 +1680,7 @@ public class UFTest extends CQLTester
createTable("CREATE TABLE %s (key int primary key, val double)");
execute("INSERT INTO %s (key, val) VALUES (?, ?)", 1, 1d);
- Object[][] variations = new Object[][]
- {
+ Object[][] variations = {
new Object[] { "true", "boolean", true },
new Object[] { "false", "boolean", false },
new Object[] { "100", "int", 100 },
@@ -1708,7 +1703,7 @@ public class UFTest extends CQLTester
String fName = createFunction(KEYSPACE, "double",
"CREATE OR REPLACE FUNCTION %s(val double) " +
- "RETURNS " +returnType + " " +
+ "RETURNS " +returnType + ' ' +
"LANGUAGE javascript " +
"AS '" + functionBody + ";';");
assertRows(execute("SELECT key, val, " + fName + "(val) FROM %s"),
@@ -1723,8 +1718,7 @@ public class UFTest extends CQLTester
execute("INSERT INTO %s (key, ival, lval, fval, dval, vval, ddval) VALUES (?, ?, ?, ?, ?, ?, ?)", 1,
1, 1L, 1f, 1d, BigInteger.valueOf(1L), BigDecimal.valueOf(1d));
- Object[][] variations = new Object[][]
- {
+ Object[][] variations = {
new Object[] { "int", "ival", 1, 2 },
new Object[] { "bigint", "lval", 1L, 2L },
new Object[] { "float", "fval", 1f, 2f },
@@ -1741,10 +1735,10 @@ public class UFTest extends CQLTester
Object expected2 = variation[3];
String fName = createFunction(KEYSPACE, type.toString(),
"CREATE OR REPLACE FUNCTION %s(val " + type + ") " +
- "RETURNS " + type + " " +
+ "RETURNS " + type + ' ' +
"LANGUAGE javascript " +
"AS 'val+1;';");
- assertRows(execute("SELECT key, " + col + ", " + fName + "(" + col + ") FROM %s"),
+ assertRows(execute("SELECT key, " + col + ", " + fName + '(' + col + ") FROM %s"),
row(1, expected1, expected2));
}
}