bahman/scylla
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

cql3: convert type_cast to C++

Browse Source
This commit is contained in:
Avi Kivity
2015-04-07 23:09:23 +03:00
committed by Tomasz Grabiec
parent 4874ac5c98
commit cfac0c5105
2 changed files with 73 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
cql3/TypeCast.java
View File

@@ -1,73 +0,0 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
package org.apache.cassandra.cql3;
import org.apache.cassandra.db.marshal.AbstractType;
import org.apache.cassandra.exceptions.InvalidRequestException;
public class TypeCast implements Term.Raw
{
private final CQL3Type.Raw type;
private final Term.Raw term;
public TypeCast(CQL3Type.Raw type, Term.Raw term)
{
this.type = type;
this.term = term;
}
public Term prepare(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
if (!term.testAssignment(keyspace, castedSpecOf(keyspace, receiver)).isAssignable())
throw new InvalidRequestException(String.format("Cannot cast value %s to type %s", term, type));
if (!testAssignment(keyspace, receiver).isAssignable())
throw new InvalidRequestException(String.format("Cannot assign value %s to %s of type %s", this, receiver.name, receiver.type.asCQL3Type()));
return term.prepare(keyspace, receiver);
}
private ColumnSpecification castedSpecOf(String keyspace, ColumnSpecification receiver) throws InvalidRequestException
{
return new ColumnSpecification(receiver.ksName, receiver.cfName, new ColumnIdentifier(toString(), true), type.prepare(keyspace).getType());
}
public AssignmentTestable.TestResult testAssignment(String keyspace, ColumnSpecification receiver)
{
try
{
AbstractType<?> castedType = type.prepare(keyspace).getType();
if (receiver.type.equals(castedType))
return AssignmentTestable.TestResult.EXACT_MATCH;
else if (receiver.type.isValueCompatibleWith(castedType))
return AssignmentTestable.TestResult.WEAKLY_ASSIGNABLE;
else
return AssignmentTestable.TestResult.NOT_ASSIGNABLE;
}
catch (InvalidRequestException e)
{
throw new AssertionError();
}
}
@Override
public String toString()
{
return "(" + type + ")" + term;
}
}

73
cql3/type_cast.hh Normal file
View File

@@ -0,0 +1,73 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
*/
/*
* Modified by Cloudius Systems
* Copyright 2015 Cloudius Systems
*/
#pragma once
#include "term.hh"
#include "cql3_type.hh"
namespace cql3 {
class type_cast : public term::raw {
shared_ptr<cql3_type::raw> _type;
shared_ptr<term::raw> _term;
public:
type_cast(shared_ptr<cql3_type::raw> type, shared_ptr<cql3::term::raw> term)
: _type(std::move(type)), _term(std::move(term)) {
}
virtual shared_ptr<term> prepare(const sstring& keyspace, shared_ptr<column_specification> receiver) override {
if (!is_assignable(_term->test_assignment(keyspace, casted_spec_of(keyspace, receiver)))) {
throw exceptions::invalid_request_exception(sprint("Cannot cast value %s to type %s", _term, _type));
}
if (!is_assignable(test_assignment(keyspace, receiver))) {
throw exceptions::invalid_request_exception(sprint("Cannot assign value %s to %s of type %s", *this, receiver->name, receiver->type->as_cql3_type()));
}
return _term->prepare(keyspace, receiver);
}
private:
shared_ptr<column_specification> casted_spec_of(const sstring& keyspace, shared_ptr<column_specification> receiver) {
return make_shared<column_specification>(receiver->ks_name, receiver->cf_name,
make_shared<column_identifier>(to_string(), true), _type->prepare(keyspace)->get_type());
}
public:
virtual assignment_testable::test_result test_assignment(const sstring& keyspace, shared_ptr<column_specification> receiver) override {
try {
auto&& casted_type = _type->prepare(keyspace)->get_type();
if (receiver->type->equals(casted_type)) {
return assignment_testable::test_result::EXACT_MATCH;
} else if (receiver->type->is_value_compatible_with(*casted_type)) {
return assignment_testable::test_result::WEAKLY_ASSIGNABLE;
} else {
return assignment_testable::test_result::NOT_ASSIGNABLE;
}
} catch (exceptions::invalid_request_exception& e) {
abort();
}
}
virtual sstring to_string() const override {
return sprint("(%s)%s", _type, _term);
}
};
}