title
stringclasses 1
value | text
stringlengths 49
954k
| id
stringlengths 27
30
|
|---|---|---|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorModule.java/RedisConnectorModule/TypeDeserializer
class RedisConnectorModule: @Inject
public TypeDeserializer(TypeManager typeManager)
{
super(Type.class);
this.typeManager = requireNonNull(typeManager, "typeManager is null");
}
|
negative_train_query0_00198
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorModule.java/TypeDeserializer/TypeDeserializer
class TypeDeserializer: @Inject
public TypeDeserializer(TypeManager typeManager)
{
super(Type.class);
this.typeManager = requireNonNull(typeManager, "typeManager is null");
}
|
negative_train_query0_00199
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorModule.java/TypeDeserializer/_deserialize
class TypeDeserializer: @Override
protected Type _deserialize(String value, DeserializationContext context)
{
return typeManager.getType(TypeId.of(value));
}
|
negative_train_query0_00200
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisDecoderModule.java/RedisDecoderModule/configure
class RedisDecoderModule: @Override
public void configure(Binder binder)
{
MapBinder<String, RowDecoderFactory> decoderFactoriesByName = MapBinder.newMapBinder(binder, String.class, RowDecoderFactory.class);
decoderFactoriesByName.addBinding(DummyRowDecoder.NAME).to(DummyRowDecoderFactory.class).in(SINGLETON);
decoderFactoriesByName.addBinding(CsvRowDecoder.NAME).to(CsvRowDecoderFactory.class).in(SINGLETON);
decoderFactoriesByName.addBinding(JsonRowDecoder.NAME).to(JsonRowDecoderFactory.class).in(SINGLETON);
decoderFactoriesByName.addBinding(RawRowDecoder.NAME).to(RawRowDecoderFactory.class).in(SINGLETON);
decoderFactoriesByName.addBinding(ZsetRedisRowDecoder.NAME).to(ZsetRedisRowDecoderFactory.class).in(SINGLETON);
decoderFactoriesByName.addBinding(HashRedisRowDecoder.NAME).to(HashRedisRowDecoderFactory.class).in(SINGLETON);
decoderFactoriesByName.addBinding(AvroRowDecoder.NAME).to(AvroRowDecoderFactory.class).in(SINGLETON);
binder.bind(DispatchingRowDecoderFactory.class).in(SINGLETON);
}
|
negative_train_query0_00201
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setTableDescriptionDir
class RedisConnectorConfig: @Config("redis.table-description-dir")
public RedisConnectorConfig setTableDescriptionDir(File tableDescriptionDir)
{
this.tableDescriptionDir = tableDescriptionDir;
return this;
}
|
negative_train_query0_00202
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setNodes
class RedisConnectorConfig: @Config("redis.nodes")
public RedisConnectorConfig setNodes(String nodes)
{
this.nodes = (nodes == null) ? null : parseNodes(nodes);
return this;
}
|
negative_train_query0_00203
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setRedisDataBaseIndex
class RedisConnectorConfig: @Config("redis.database-index")
public RedisConnectorConfig setRedisDataBaseIndex(int redisDataBaseIndex)
{
this.redisDataBaseIndex = redisDataBaseIndex;
return this;
}
|
negative_train_query0_00204
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setHideInternalColumns
class RedisConnectorConfig: @Config("redis.hide-internal-columns")
public RedisConnectorConfig setHideInternalColumns(boolean hideInternalColumns)
{
this.hideInternalColumns = hideInternalColumns;
return this;
}
|
negative_train_query0_00205
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getTableDescriptionDir
class RedisConnectorConfig: @NotNull
public File getTableDescriptionDir()
{
return tableDescriptionDir;
}
|
negative_train_query0_00206
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getTableNames
class RedisConnectorConfig: @NotNull
public Set<String> getTableNames()
{
return tableNames;
}
|
negative_train_query0_00207
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getRedisScanCount
class RedisConnectorConfig: public int getRedisScanCount()
{
return redisScanCount;
}
|
negative_train_query0_00208
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getRedisConnectTimeout
class RedisConnectorConfig: @MinDuration("1s")
public Duration getRedisConnectTimeout()
{
return redisConnectTimeout;
}
|
negative_train_query0_00209
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/isKeyPrefixSchemaTable
class RedisConnectorConfig: public boolean isKeyPrefixSchemaTable()
{
return keyPrefixSchemaTable;
}
|
negative_train_query0_00210
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setKeyPrefixSchemaTable
class RedisConnectorConfig: @Config("redis.key-prefix-schema-table")
public RedisConnectorConfig setKeyPrefixSchemaTable(boolean keyPrefixSchemaTable)
{
this.keyPrefixSchemaTable = keyPrefixSchemaTable;
return this;
}
|
negative_train_query0_00211
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/parseNodes
class RedisConnectorConfig: public static ImmutableSet<HostAddress> parseNodes(String nodes)
{
Splitter splitter = Splitter.on(',').omitEmptyStrings().trimResults();
return StreamSupport.stream(splitter.split(nodes).spliterator(), false)
.map(RedisConnectorConfig::toHostAddress)
.collect(toImmutableSet());
}
|
negative_train_query0_00212
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setRedisScanCount
class RedisConnectorConfig: @Config("redis.scan-count")
public RedisConnectorConfig setRedisScanCount(int redisScanCount)
{
this.redisScanCount = redisScanCount;
return this;
}
|
negative_train_query0_00213
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setRedisPassword
class RedisConnectorConfig: @Config("redis.password")
@ConfigSecuritySensitive
public RedisConnectorConfig setRedisPassword(String redisPassword)
{
this.redisPassword = redisPassword;
return this;
}
|
negative_train_query0_00214
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getRedisDataBaseIndex
class RedisConnectorConfig: public int getRedisDataBaseIndex()
{
return redisDataBaseIndex;
}
|
negative_train_query0_00215
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/isHideInternalColumns
class RedisConnectorConfig: public boolean isHideInternalColumns()
{
return hideInternalColumns;
}
|
negative_train_query0_00216
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setTableNames
class RedisConnectorConfig: @Config("redis.table-names")
public RedisConnectorConfig setTableNames(String tableNames)
{
this.tableNames = ImmutableSet.copyOf(Splitter.on(',').omitEmptyStrings().trimResults().split(tableNames));
return this;
}
|
negative_train_query0_00217
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setDefaultSchema
class RedisConnectorConfig: @Config("redis.default-schema")
public RedisConnectorConfig setDefaultSchema(String defaultSchema)
{
this.defaultSchema = defaultSchema;
return this;
}
|
negative_train_query0_00218
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setRedisConnectTimeout
class RedisConnectorConfig: @Config("redis.connect-timeout")
public RedisConnectorConfig setRedisConnectTimeout(String redisConnectTimeout)
{
this.redisConnectTimeout = Duration.valueOf(redisConnectTimeout);
return this;
}
|
negative_train_query0_00219
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/setRedisKeyDelimiter
class RedisConnectorConfig: @Config("redis.key-delimiter")
public RedisConnectorConfig setRedisKeyDelimiter(String redisKeyDelimiter)
{
this.redisKeyDelimiter = redisKeyDelimiter.charAt(0);
return this;
}
|
negative_train_query0_00220
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getDefaultSchema
class RedisConnectorConfig: @NotNull
public String getDefaultSchema()
{
return defaultSchema;
}
|
negative_train_query0_00221
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getNodes
class RedisConnectorConfig: @Size(min = 1)
public Set<HostAddress> getNodes()
{
return nodes;
}
|
negative_train_query0_00222
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getRedisKeyDelimiter
class RedisConnectorConfig: public char getRedisKeyDelimiter()
{
return redisKeyDelimiter;
}
|
negative_train_query0_00223
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/getRedisPassword
class RedisConnectorConfig: public String getRedisPassword()
{
return redisPassword;
}
|
negative_train_query0_00224
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorConfig.java/RedisConnectorConfig/toHostAddress
class RedisConnectorConfig: private static HostAddress toHostAddress(String value)
{
return HostAddress.fromString(value).withDefaultPort(REDIS_DEFAULT_PORT);
}
|
negative_train_query0_00225
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordSet.java/RedisRecordSet/RedisRecordSet
class RedisRecordSet: RedisRecordSet(
RedisSplit split,
RedisJedisManager jedisManager,
List<RedisColumnHandle> columnHandles,
RowDecoder keyDecoder,
RowDecoder valueDecoder)
{
this.split = requireNonNull(split, "split is null");
this.jedisManager = requireNonNull(jedisManager, "jedisManager is null");
this.keyDecoder = requireNonNull(keyDecoder, "keyDecoder is null");
this.valueDecoder = requireNonNull(valueDecoder, "valueDecoder is null");
this.columnHandles = requireNonNull(columnHandles, "columnHandles is null");
ImmutableList.Builder<Type> typeBuilder = ImmutableList.builder();
for (DecoderColumnHandle handle : columnHandles) {
typeBuilder.add(handle.getType());
}
this.columnTypes = typeBuilder.build();
}
|
negative_train_query0_00226
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordSet.java/RedisRecordSet/cursor
class RedisRecordSet: @Override
public RecordCursor cursor()
{
return new RedisRecordCursor(keyDecoder, valueDecoder, split, columnHandles, jedisManager);
}
|
negative_train_query0_00227
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordSet.java/RedisRecordSet/getColumnTypes
class RedisRecordSet: @Override
public List<Type> getColumnTypes()
{
return columnTypes;
}
|
negative_train_query0_00228
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorFactory.java/RedisConnectorFactory/RedisConnectorFactory
class RedisConnectorFactory: RedisConnectorFactory(Optional<Supplier<Map<SchemaTableName, RedisTableDescription>>> tableDescriptionSupplier)
{
this.tableDescriptionSupplier = requireNonNull(tableDescriptionSupplier, "tableDescriptionSupplier is null");
}
|
negative_train_query0_00229
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorFactory.java/RedisConnectorFactory/getHandleResolver
class RedisConnectorFactory: @Override
public ConnectorHandleResolver getHandleResolver()
{
return new RedisHandleResolver();
}
|
negative_train_query0_00230
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorFactory.java/RedisConnectorFactory/create
class RedisConnectorFactory: @Override
public Connector create(String catalogName, Map<String, String> config, ConnectorContext context)
{
requireNonNull(catalogName, "catalogName is null");
requireNonNull(config, "config is null");
Bootstrap app = new Bootstrap(
new JsonModule(),
new RedisConnectorModule(),
binder -> {
binder.bind(TypeManager.class).toInstance(context.getTypeManager());
binder.bind(NodeManager.class).toInstance(context.getNodeManager());
if (tableDescriptionSupplier.isPresent()) {
binder.bind(new TypeLiteral<Supplier<Map<SchemaTableName, RedisTableDescription>>>() {}).toInstance(tableDescriptionSupplier.get());
}
else {
binder.bind(new TypeLiteral<Supplier<Map<SchemaTableName, RedisTableDescription>>>() {})
.to(RedisTableDescriptionSupplier.class)
.in(Scopes.SINGLETON);
}
});
Injector injector = app.strictConfig()
.doNotInitializeLogging()
.setRequiredConfigurationProperties(config)
.initialize();
return injector.getInstance(RedisConnector.class);
}
|
negative_train_query0_00231
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisConnectorFactory.java/RedisConnectorFactory/getName
class RedisConnectorFactory: @Override
public String getName()
{
return "redis";
}
|
negative_train_query0_00232
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisFieldDecoder.java/RedisFieldDecoder/decode
class RedisFieldDecoder: FieldValueProvider decode(T value, DecoderColumnHandle columnHandle);
|
negative_train_query0_00233
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisHandleResolver.java/RedisHandleResolver/getTransactionHandleClass
class RedisHandleResolver: @Override
public Class<? extends ConnectorTransactionHandle> getTransactionHandleClass()
{
return RedisTransactionHandle.class;
}
|
negative_train_query0_00234
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisHandleResolver.java/RedisHandleResolver/getColumnHandleClass
class RedisHandleResolver: @Override
public Class<? extends ColumnHandle> getColumnHandleClass()
{
return RedisColumnHandle.class;
}
|
negative_train_query0_00235
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisHandleResolver.java/RedisHandleResolver/convertTableHandle
class RedisHandleResolver: static RedisTableHandle convertTableHandle(ConnectorTableHandle tableHandle)
{
requireNonNull(tableHandle, "tableHandle is null");
checkArgument(tableHandle instanceof RedisTableHandle, "tableHandle is not an instance of RedisTableHandle");
return (RedisTableHandle) tableHandle;
}
|
negative_train_query0_00236
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisHandleResolver.java/RedisHandleResolver/getSplitClass
class RedisHandleResolver: @Override
public Class<? extends ConnectorSplit> getSplitClass()
{
return RedisSplit.class;
}
|
negative_train_query0_00237
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisHandleResolver.java/RedisHandleResolver/getTableHandleClass
class RedisHandleResolver: @Override
public Class<? extends ConnectorTableHandle> getTableHandleClass()
{
return RedisTableHandle.class;
}
|
negative_train_query0_00238
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisHandleResolver.java/RedisHandleResolver/convertColumnHandle
class RedisHandleResolver: static RedisColumnHandle convertColumnHandle(ColumnHandle columnHandle)
{
requireNonNull(columnHandle, "columnHandle is null");
checkArgument(columnHandle instanceof RedisColumnHandle, "columnHandle is not an instance of RedisColumnHandle");
return (RedisColumnHandle) columnHandle;
}
|
negative_train_query0_00239
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisHandleResolver.java/RedisHandleResolver/convertSplit
class RedisHandleResolver: static RedisSplit convertSplit(ConnectorSplit split)
{
requireNonNull(split, "split is null");
checkArgument(split instanceof RedisSplit, "split is not an instance of RedisSplit");
return (RedisSplit) split;
}
|
negative_train_query0_00240
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/advanceNextPosition
class RedisRecordCursor: @Override
public boolean advanceNextPosition()
{
while (!keysIterator.hasNext()) {
if (!hasUnscannedData()) {
return endOfData();
}
fetchKeys();
}
return nextRow(keysIterator.next());
}
|
negative_train_query0_00241
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/endOfData
class RedisRecordCursor: private boolean endOfData()
{
if (!reported.getAndSet(true)) {
log.debug("Read a total of %d values with %d bytes.", totalValues, totalBytes);
}
return false;
}
|
negative_train_query0_00242
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getType
class RedisRecordCursor: @Override
public Type getType(int field)
{
checkArgument(field < columnHandles.size(), "Invalid field index");
return columnHandles.get(field).getType();
}
|
negative_train_query0_00243
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getCompletedBytes
class RedisRecordCursor: @Override
public long getCompletedBytes()
{
return totalBytes;
}
|
negative_train_query0_00244
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/nextRow
class RedisRecordCursor: private boolean nextRow(String keyString)
{
fetchData(keyString);
byte[] keyData = keyString.getBytes(StandardCharsets.UTF_8);
byte[] valueData = EMPTY_BYTE_ARRAY;
if (valueString != null) {
valueData = valueString.getBytes(StandardCharsets.UTF_8);
}
totalBytes += valueData.length;
totalValues++;
Optional<Map<DecoderColumnHandle, FieldValueProvider>> decodedKey = keyDecoder.decodeRow(
keyData,
null);
Optional<Map<DecoderColumnHandle, FieldValueProvider>> decodedValue = valueDecoder.decodeRow(
valueData,
valueMap);
Map<ColumnHandle, FieldValueProvider> currentRowValuesMap = new HashMap<>();
for (DecoderColumnHandle columnHandle : columnHandles) {
if (columnHandle.isInternal()) {
RedisInternalFieldDescription fieldDescription = RedisInternalFieldDescription.forColumnName(columnHandle.getName());
switch (fieldDescription) {
case KEY_FIELD:
currentRowValuesMap.put(columnHandle, bytesValueProvider(keyData));
break;
case VALUE_FIELD:
currentRowValuesMap.put(columnHandle, bytesValueProvider(valueData));
break;
case KEY_LENGTH_FIELD:
currentRowValuesMap.put(columnHandle, longValueProvider(keyData.length));
break;
case VALUE_LENGTH_FIELD:
currentRowValuesMap.put(columnHandle, longValueProvider(valueData.length));
break;
case KEY_CORRUPT_FIELD:
currentRowValuesMap.put(columnHandle, booleanValueProvider(!decodedKey.isPresent()));
break;
case VALUE_CORRUPT_FIELD:
currentRowValuesMap.put(columnHandle, booleanValueProvider(!decodedValue.isPresent()));
break;
default:
throw new IllegalArgumentException("unknown internal field " + fieldDescription);
}
}
}
decodedKey.ifPresent(currentRowValuesMap::putAll);
decodedValue.ifPresent(currentRowValuesMap::putAll);
for (int i = 0; i < columnHandles.size(); i++) {
ColumnHandle columnHandle = columnHandles.get(i);
currentRowValues[i] = currentRowValuesMap.get(columnHandle);
}
return true;
}
|
negative_train_query0_00245
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getLong
class RedisRecordCursor: @Override
public long getLong(int field)
{
return getFieldValueProvider(field, long.class).getLong();
}
|
negative_train_query0_00246
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getObject
class RedisRecordCursor: @Override
public Object getObject(int field)
{
checkArgument(field < columnHandles.size(), "Invalid field index");
throw new IllegalArgumentException(format("Type %s is not supported", getType(field)));
}
|
negative_train_query0_00247
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getReadTimeNanos
class RedisRecordCursor: @Override
public long getReadTimeNanos()
{
return 0;
}
|
negative_train_query0_00248
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/hasUnscannedData
class RedisRecordCursor: public boolean hasUnscannedData()
{
if (redisCursor == null) {
return false;
}
// no more keys are unscanned when
// when redis scan command
// returns 0 string cursor
return (!redisCursor.getStringCursor().equals("0"));
}
|
negative_train_query0_00249
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getBoolean
class RedisRecordCursor: @Override
public boolean getBoolean(int field)
{
return getFieldValueProvider(field, boolean.class).getBoolean();
}
|
negative_train_query0_00250
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getDouble
class RedisRecordCursor: @Override
public double getDouble(int field)
{
return getFieldValueProvider(field, double.class).getDouble();
}
|
negative_train_query0_00251
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getFieldValueProvider
class RedisRecordCursor: private FieldValueProvider getFieldValueProvider(int field, Class<?> expectedType)
{
checkArgument(field < columnHandles.size(), "Invalid field index");
checkFieldType(field, expectedType);
return currentRowValues[field];
}
|
negative_train_query0_00252
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/fetchKeys
class RedisRecordCursor: private boolean fetchKeys()
{
try (Jedis jedis = jedisPool.getResource()) {
switch (split.getKeyDataType()) {
case STRING: {
String cursor = SCAN_POINTER_START;
if (redisCursor != null) {
cursor = redisCursor.getStringCursor();
}
log.debug("Scanning new Redis keys from cursor %s . %d values read so far", cursor, totalValues);
redisCursor = jedis.scan(cursor, scanParms);
List<String> keys = redisCursor.getResult();
keysIterator = keys.iterator();
}
break;
case ZSET:
Set<String> keys = jedis.zrange(split.getKeyName(), split.getStart(), split.getEnd());
keysIterator = keys.iterator();
break;
default:
log.debug("Redis type of key %s is unsupported", split.getKeyDataFormat());
return false;
}
}
return true;
}
|
negative_train_query0_00253
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/setScanParms
class RedisRecordCursor: private ScanParams setScanParms()
{
if (split.getKeyDataType() == RedisDataType.STRING) {
ScanParams scanParms = new ScanParams();
scanParms.count(redisJedisManager.getRedisConnectorConfig().getRedisScanCount());
// when Redis key string follows "schema:table:*" format
// scan command can efficiently query tables
// by returning matching keys
// the alternative is to set key-prefix-schema-table to false
// and treat entire redis as single schema , single table
// redis Hash/Set types are to be supported - they can also be
// used to filter out table data
// "default" schema is not prefixed to the key
if (redisJedisManager.getRedisConnectorConfig().isKeyPrefixSchemaTable()) {
String keyMatch = "";
if (!split.getSchemaName().equals("default")) {
keyMatch = split.getSchemaName() + Character.toString(redisJedisManager.getRedisConnectorConfig().getRedisKeyDelimiter());
}
keyMatch = keyMatch + split.getTableName() + Character.toString(redisJedisManager.getRedisConnectorConfig().getRedisKeyDelimiter()) + "*";
scanParms.match(keyMatch);
}
return scanParms;
}
return null;
}
|
negative_train_query0_00254
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/getSlice
class RedisRecordCursor: @Override
public Slice getSlice(int field)
{
return getFieldValueProvider(field, Slice.class).getSlice();
}
|
negative_train_query0_00255
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/checkFieldType
class RedisRecordCursor: private void checkFieldType(int field, Class<?> expected)
{
Class<?> actual = getType(field).getJavaType();
checkArgument(actual == expected, "Expected field %s to be type %s but is %s", field, expected, actual);
}
|
negative_train_query0_00256
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/isNull
class RedisRecordCursor: @Override
public boolean isNull(int field)
{
checkArgument(field < columnHandles.size(), "Invalid field index");
return currentRowValues == null || currentRowValues[field].isNull();
}
|
negative_train_query0_00257
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/close
class RedisRecordCursor: @Override
public void close()
{
}
|
negative_train_query0_00258
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/fetchData
class RedisRecordCursor: private boolean fetchData(String keyString)
{
valueString = null;
valueMap = null;
// Redis connector supports two types of Redis
// values: STRING and HASH
// HASH types requires hash row decoder to
// fill in the columns
// whereas for the STRING type decoders are optional
try (Jedis jedis = jedisPool.getResource()) {
switch (split.getValueDataType()) {
case STRING:
valueString = jedis.get(keyString);
if (valueString == null) {
log.warn("Redis data modified while query was running, string value at key %s deleted", keyString);
return false;
}
break;
case HASH:
valueMap = jedis.hgetAll(keyString);
if (valueMap == null) {
log.warn("Redis data modified while query was running, hash value at key %s deleted", keyString);
return false;
}
break;
default:
log.debug("Redis type for key %s is unsupported", keyString);
return false;
}
}
return true;
}
|
negative_train_query0_00259
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisRecordCursor.java/RedisRecordCursor/RedisRecordCursor
class RedisRecordCursor: RedisRecordCursor(
RowDecoder keyDecoder,
RowDecoder valueDecoder,
RedisSplit split,
List<RedisColumnHandle> columnHandles,
RedisJedisManager redisJedisManager)
{
this.keyDecoder = keyDecoder;
this.valueDecoder = valueDecoder;
this.split = split;
this.columnHandles = columnHandles;
this.redisJedisManager = redisJedisManager;
this.jedisPool = redisJedisManager.getJedisPool(split.getNodes().get(0));
this.scanParms = setScanParms();
this.currentRowValues = new FieldValueProvider[columnHandles.size()];
fetchKeys();
}
|
negative_train_query0_00260
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/getDataFormat
class RedisMetadata: private static String getDataFormat(RedisTableFieldGroup fieldGroup)
{
return (fieldGroup == null) ? DummyRowDecoder.NAME : fieldGroup.getDataFormat();
}
|
negative_train_query0_00261
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/listSchemaNames
class RedisMetadata: @Override
public List<String> listSchemaNames(ConnectorSession session)
{
Set<String> schemas = getDefinedTables().keySet().stream()
.map(SchemaTableName::getSchemaName)
.collect(Collectors.toCollection(LinkedHashSet::new));
return ImmutableList.copyOf(schemas);
}
|
negative_train_query0_00262
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/listTables
class RedisMetadata: @Override
public List<SchemaTableName> listTables(ConnectorSession session, Optional<String> schemaName)
{
ImmutableList.Builder<SchemaTableName> builder = ImmutableList.builder();
for (SchemaTableName tableName : getDefinedTables().keySet()) {
if (schemaName.map(tableName.getSchemaName()::equals).orElse(true)) {
builder.add(tableName);
}
}
return builder.build();
}
|
negative_train_query0_00263
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/listTableColumns
class RedisMetadata: @Override
public Map<SchemaTableName, List<ColumnMetadata>> listTableColumns(ConnectorSession session, SchemaTablePrefix prefix)
{
requireNonNull(prefix, "prefix is null");
ImmutableMap.Builder<SchemaTableName, List<ColumnMetadata>> columns = ImmutableMap.builder();
List<SchemaTableName> tableNames;
if (!prefix.getTable().isPresent()) {
tableNames = listTables(session, prefix.getSchema());
}
else {
tableNames = ImmutableList.of(prefix.toSchemaTableName());
}
for (SchemaTableName tableName : tableNames) {
ConnectorTableMetadata tableMetadata = getTableMetadata(tableName);
// table can disappear during listing operation
if (tableMetadata != null) {
columns.put(tableName, tableMetadata.getColumns());
}
}
return columns.build();
}
|
negative_train_query0_00264
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/usesLegacyTableLayouts
class RedisMetadata: @Override
public boolean usesLegacyTableLayouts()
{
return false;
}
|
negative_train_query0_00265
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/getDefinedTables
class RedisMetadata: @VisibleForTesting
Map<SchemaTableName, RedisTableDescription> getDefinedTables()
{
return redisTableDescriptionSupplier.get();
}
|
negative_train_query0_00266
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/RedisMetadata
class RedisMetadata: @Inject
RedisMetadata(
RedisConnectorConfig redisConnectorConfig,
Supplier<Map<SchemaTableName, RedisTableDescription>> redisTableDescriptionSupplier)
{
requireNonNull(redisConnectorConfig, "redisConfig is null");
hideInternalColumns = redisConnectorConfig.isHideInternalColumns();
log.debug("Loading redis table definitions from %s", redisConnectorConfig.getTableDescriptionDir().getAbsolutePath());
this.redisTableDescriptionSupplier = Suppliers.memoize(redisTableDescriptionSupplier::get)::get;
}
|
negative_train_query0_00267
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/getTableMetadata
class RedisMetadata: @Nullable
private ConnectorTableMetadata getTableMetadata(SchemaTableName schemaTableName)
{
RedisTableDescription table = getDefinedTables().get(schemaTableName);
if (table == null) {
return null;
}
ImmutableList.Builder<ColumnMetadata> builder = ImmutableList.builder();
appendFields(builder, table.getKey());
appendFields(builder, table.getValue());
for (RedisInternalFieldDescription fieldDescription : RedisInternalFieldDescription.values()) {
builder.add(fieldDescription.getColumnMetadata(hideInternalColumns));
}
return new ConnectorTableMetadata(schemaTableName, builder.build());
}
|
negative_train_query0_00268
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/getTableHandle
class RedisMetadata: @Override
public RedisTableHandle getTableHandle(ConnectorSession session, SchemaTableName schemaTableName)
{
RedisTableDescription table = getDefinedTables().get(schemaTableName);
if (table == null) {
return null;
}
// check if keys are supplied in a zset
// via the table description doc
String keyName = null;
if (table.getKey() != null) {
keyName = table.getKey().getName();
}
return new RedisTableHandle(
schemaTableName.getSchemaName(),
schemaTableName.getTableName(),
getDataFormat(table.getKey()),
getDataFormat(table.getValue()),
keyName);
}
|
negative_train_query0_00269
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/getColumnHandles
class RedisMetadata: @Override
public Map<String, ColumnHandle> getColumnHandles(ConnectorSession session, ConnectorTableHandle tableHandle)
{
RedisTableHandle redisTableHandle = convertTableHandle(tableHandle);
RedisTableDescription redisTableDescription = getDefinedTables().get(redisTableHandle.toSchemaTableName());
if (redisTableDescription == null) {
throw new TableNotFoundException(redisTableHandle.toSchemaTableName());
}
ImmutableMap.Builder<String, ColumnHandle> columnHandles = ImmutableMap.builder();
int index = 0;
RedisTableFieldGroup key = redisTableDescription.getKey();
if (key != null) {
List<RedisTableFieldDescription> fields = key.getFields();
if (fields != null) {
for (RedisTableFieldDescription field : fields) {
columnHandles.put(field.getName(), field.getColumnHandle(true, index));
index++;
}
}
}
RedisTableFieldGroup value = redisTableDescription.getValue();
if (value != null) {
List<RedisTableFieldDescription> fields = value.getFields();
if (fields != null) {
for (RedisTableFieldDescription field : fields) {
columnHandles.put(field.getName(), field.getColumnHandle(false, index));
index++;
}
}
}
for (RedisInternalFieldDescription field : RedisInternalFieldDescription.values()) {
columnHandles.put(field.getColumnName(), field.getColumnHandle(index, hideInternalColumns));
index++;
}
return columnHandles.build();
}
|
negative_train_query0_00270
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/getColumnMetadata
class RedisMetadata: @Override
public ColumnMetadata getColumnMetadata(ConnectorSession session, ConnectorTableHandle tableHandle, ColumnHandle columnHandle)
{
convertTableHandle(tableHandle);
return convertColumnHandle(columnHandle).getColumnMetadata();
}
|
negative_train_query0_00271
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/getTableProperties
class RedisMetadata: @Override
public ConnectorTableProperties getTableProperties(ConnectorSession session, ConnectorTableHandle tableHandle)
{
return new ConnectorTableProperties();
}
|
negative_train_query0_00272
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisMetadata.java/RedisMetadata/appendFields
class RedisMetadata: private static void appendFields(ImmutableList.Builder<ColumnMetadata> builder, RedisTableFieldGroup group)
{
if (group != null) {
List<RedisTableFieldDescription> fields = group.getFields();
if (fields != null) {
for (RedisTableFieldDescription fieldDescription : fields) {
builder.add(fieldDescription.getColumnMetadata());
}
}
}
}
|
negative_train_query0_00273
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getKeyDataFormat
class RedisSplit: @JsonProperty
public String getKeyDataFormat()
{
return keyDataFormat;
}
|
negative_train_query0_00274
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getSchemaName
class RedisSplit: @JsonProperty
public String getSchemaName()
{
return schemaName;
}
|
negative_train_query0_00275
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getKeyName
class RedisSplit: @JsonProperty
public String getKeyName()
{
return keyName;
}
|
negative_train_query0_00276
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getValueDataType
class RedisSplit: public RedisDataType getValueDataType()
{
return valueDataType;
}
|
negative_train_query0_00277
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getStart
class RedisSplit: @JsonProperty
public long getStart()
{
return start;
}
|
negative_train_query0_00278
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/isRemotelyAccessible
class RedisSplit: @Override
public boolean isRemotelyAccessible()
{
return true;
}
|
negative_train_query0_00279
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getInfo
class RedisSplit: @Override
public Object getInfo()
{
return this;
}
|
negative_train_query0_00280
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/RedisSplit
class RedisSplit: @JsonCreator
public RedisSplit(
@JsonProperty("schemaName") String schemaName,
@JsonProperty("tableName") String tableName,
@JsonProperty("keyDataFormat") String keyDataFormat,
@JsonProperty("valueDataFormat") String valueDataFormat,
@JsonProperty("keyName") String keyName,
@JsonProperty("start") long start,
@JsonProperty("end") long end,
@JsonProperty("nodes") List<HostAddress> nodes)
{
this.schemaName = requireNonNull(schemaName, "schemaName is null");
this.tableName = requireNonNull(tableName, "tableName is null");
this.keyDataFormat = requireNonNull(keyDataFormat, "keyDataFormat is null");
this.valueDataFormat = requireNonNull(valueDataFormat, "valueDataFormat is null");
this.keyName = keyName;
this.nodes = ImmutableList.copyOf(requireNonNull(nodes, "nodes is null"));
this.start = start;
this.end = end;
this.valueDataType = toRedisDataType(valueDataFormat);
this.keyDataType = toRedisDataType(keyDataFormat);
}
|
negative_train_query0_00281
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getValueDataFormat
class RedisSplit: @JsonProperty
public String getValueDataFormat()
{
return valueDataFormat;
}
|
negative_train_query0_00282
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getTableName
class RedisSplit: @JsonProperty
public String getTableName()
{
return tableName;
}
|
negative_train_query0_00283
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getNodes
class RedisSplit: @JsonProperty
public List<HostAddress> getNodes()
{
return nodes;
}
|
negative_train_query0_00284
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getKeyDataType
class RedisSplit: public RedisDataType getKeyDataType()
{
return keyDataType;
}
|
negative_train_query0_00285
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getEnd
class RedisSplit: @JsonProperty
public long getEnd()
{
return end;
}
|
negative_train_query0_00286
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/getAddresses
class RedisSplit: @Override
public List<HostAddress> getAddresses()
{
return nodes;
}
|
negative_train_query0_00287
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/toRedisDataType
class RedisSplit: private static RedisDataType toRedisDataType(String dataFormat)
{
switch (dataFormat) {
case "hash":
return RedisDataType.HASH;
case "zset":
return RedisDataType.ZSET;
default:
return RedisDataType.STRING;
}
}
|
negative_train_query0_00288
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisSplit.java/RedisSplit/toString
class RedisSplit: @Override
public String toString()
{
return toStringHelper(this)
.add("schemaName", schemaName)
.add("tableName", tableName)
.add("keyDataFormat", keyDataFormat)
.add("valueDataFormat", valueDataFormat)
.add("keyName", keyName)
.add("start", start)
.add("end", end)
.add("nodes", nodes)
.toString();
}
|
negative_train_query0_00289
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/getKeyDataFormat
class RedisTableHandle: @JsonProperty
public String getKeyDataFormat()
{
return keyDataFormat;
}
|
negative_train_query0_00290
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/getSchemaName
class RedisTableHandle: @JsonProperty
public String getSchemaName()
{
return schemaName;
}
|
negative_train_query0_00291
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/getValueDataFormat
class RedisTableHandle: @JsonProperty
public String getValueDataFormat()
{
return valueDataFormat;
}
|
negative_train_query0_00292
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/hashCode
class RedisTableHandle: @Override
public int hashCode()
{
return Objects.hash(schemaName, tableName, keyDataFormat, valueDataFormat, keyName);
}
|
negative_train_query0_00293
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/RedisTableHandle
class RedisTableHandle: @JsonCreator
public RedisTableHandle(
@JsonProperty("schemaName") String schemaName,
@JsonProperty("tableName") String tableName,
@JsonProperty("keyDataFormat") String keyDataFormat,
@JsonProperty("valueDataFormat") String valueDataFormat,
@JsonProperty("keyName") String keyName)
{
this.schemaName = requireNonNull(schemaName, "schemaName is null");
this.tableName = requireNonNull(tableName, "tableName is null");
this.keyDataFormat = requireNonNull(keyDataFormat, "keyDataFormat is null");
this.valueDataFormat = requireNonNull(valueDataFormat, "valueDataFormat is null");
this.keyName = keyName;
}
|
negative_train_query0_00294
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/getKeyName
class RedisTableHandle: @JsonProperty
public String getKeyName()
{
return keyName;
}
|
negative_train_query0_00295
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/getTableName
class RedisTableHandle: @JsonProperty
public String getTableName()
{
return tableName;
}
|
negative_train_query0_00296
|
|
presto-redis/src/main/java/io/prestosql/plugin/redis/RedisTableHandle.java/RedisTableHandle/toSchemaTableName
class RedisTableHandle: public SchemaTableName toSchemaTableName()
{
return new SchemaTableName(schemaName, tableName);
}
|
negative_train_query0_00297
|