Fetches the contents of a list

$listType can be one of:

0 - Databases
1 - Queries
2 - Both Databases and Queries
5 - Test Lists
6 - Seed Lists
13 - Suppression Lists
15 - Relational Tables
18 - Contact Lists
426424
public function getLists($listType = 2, $isPrivate = true, $folder = null) {
        $data["Envelope"] = array(
            "Body" => array(
                "GetLists" => array(
                    "VISIBILITY" => ($isPrivate ? '0' : '1'),
                    "FOLDER_ID" => $folder,
                    "LIST_TYPE" => $listType,
                ),
            ),
        );
        $response = $this->_request($data);
        $result = $response["Envelope"]["Body"]["RESULT"];
        if ($this->_isSuccess($result)) {
            if (isset($result['LIST']))
                return $result['LIST'];
            else {
                return array(); //?
            }
        } else {
            throw new \Exception("GetLists Error: ".$this->_getErrorFromResponse($response));
        }
    }
1204687
public Array listToArray() throws PageException {

	if (this.query instanceof QueryImpl) return ListUtil.listToArray(((QueryImpl) this.query).getColumnlist(false), ",");

	throw new ApplicationException("Query is not of type QueryImpl. Use instead Query.columnArray() or Query.columnList().listToArray().");
    }
621365
public function listToIn(array $list, &$params, $currentParamCount) {
        $currentParamCount += sizeOf($params);
        $sql = '';
        $first = true;
        foreach($list as $key => $value) {
            if(is_object($value) && method_exists($value, 'getId')) {
                $value = $value->getId();
            }
            if($first) {
                $first = false;
            } else {
                $sql .= ',';
            }
            $sql .= '?' . $currentParamCount;
            $params[$currentParamCount] = $value;
            $currentParamCount++;
        }
        return $sql;
    }
586320
def fetch_result_sets(cls, db, datasource_type):
        
        result_set_df = db.get_df(
            """SELECT table_schema, table_name FROM INFORMATION_SCHEMA.{}S
               ORDER BY concat(table_schema, '.', table_name)""".format(
                datasource_type.upper(),
            ),
            None)
        result_sets = []
        for unused, row in result_set_df.iterrows():
            result_sets.append('{}.{}'.format(
                row['table_schema'], row['table_name']))
        return result_sets
906703
public function fetch($type=SQLAnywhereClient::FETCH_ASSOC)
	{
		$data = null;
		if ($this->result) {
			switch ($type) {
				case 'array':
					$data = sasql_fetch_array( $this->result );
				break;

				case 'assoc':
					$data = sasql_fetch_assoc( $this->result );
				break;

				case 'row':
					$data = sasql_fetch_row( $this->result );
				break;

				case 'field':
					$data = sasql_fetch_field( $this->result );
				break;

				case 'object':
					$data = sasql_fetch_object( $this->result );
				break;
				
				default:
					$data = sasql_fetch_array( $this->result );
				break;
			}		
		}
		return $data;
	}
994438
def p_list_type(self, p):
        ''''''
        p[0] = ast.ListType(value_type=p[3], annotations=p[5])
290837
public function collect($job_list) {
    // TODO: is there an API for reading this file? Where?
    $definition_file = 'core/config/schema/core.data_types.schema.yml';
    $yml = file_get_contents($definition_file);
    $value = Yaml::parse($yml);

    $data_types = [];
    foreach ($value as $type => $definition_item) {
      // Skip the special types.
      if ($type == 'undefined' || $type == 'ignore') {
        continue;
      }

      // Skip compound types, until we figure out which ones we want.
      if (isset($definition_item['mapping'])) {
        continue;
      }
      if (isset($definition_item['sequence'])) {
        continue;
      }

      // Skip types with a wildcard in the name.
      if (strpos($type, '*') !== FALSE) {
        continue;
      }

      // Skip types that are to do with fields.
      if (substr($type, 0, strlen('field.')) == 'field.') {
        continue;
      }

      // Skip types that don't seem like they should be used for config
      // entities (??).
      if (substr($type, - strlen('settings')) == 'settings') {
        continue;
      }
      if (strpos($type, 'date_format') !== FALSE) {
        continue;
      }

      $data_types[$type] = [
        'type' => $type,
        'label' => $definition_item['label'],
      ];
    }

    ksort($data_types);

    // Filter for testing sample data collection.
    if (!empty($this->environment->sample_data_write)) {
      $data_types = array_intersect_key($data_types, $this->testingDataTypes);
    }

    return $data_types;
  }
927921
public function fetchAll($type = self::FETCH_TYPE_NUM)
    {
        if ($this->_allFetched) {
            return $this->buffer;
        }
        $results = $this->statement->fetchAll($type);
        if ($results !== false) {
            $this->buffer = array_merge($this->buffer, $results);
        }
        $this->_allFetched = true;
        $this->statement->closeCursor();

        return $this->buffer;
    }
168018
public function fetchTypes() {
        $response = $this->client->request('GET', 'https://crest-tq.eveonline.com/market/types/');

        return iterator_to_array($this->getOtherPages(json_decode($response->getBody()->getContents())));
    }
1254644
static function fetchListCount()
    {
        $sql = "SELECT count( node_id ) as count FROM ezcontentobject_tree";
        $db = eZDB::instance();
        $rows = $db->arrayQuery( $sql );
        return $rows[0]['count'];
    }
167751
public List< T> getAllByHql(String secondHalfOfHql, Object paramValue1, Type paramType1, Object paramValue2, Type paramType2) {
        return getAllByHql(secondHalfOfHql, new Object[] {paramValue1, paramValue2}, new Type[]{paramType2, paramType2}, null, null);
    }
533818
public function fetchAll($type = null)
    {
        try {
            if ($this->res === false) {
                throw new DatabaseException(__METHOD__ . " No ressource has been given", MySQL::NO_RESSOURCE, MySQL::SEVERITY_DEBUG, __FILE__, __LINE__);
            }

            switch ($type) {
                case MySQL::FETCH_ASSOC:
                    return $this->_db->fetch_assoc_list($this->res);
                    break;
                case MySQL::FETCH_NUM:
                    return $this->_db->fetch_num_list($this->res);
                    break;
                case MySQL::FETCH_OBJ:
                default:
                    return $this->_db->fetch_object_list($this->res);
                    break;
            }
        } catch (DatabaseException $e) {
            throw $e;
        }


    }
357765
function fetchContents()
    {
        $filePath = $this->filePath;
        eZDebugSetting::writeDebug( 'kernel-clustering', "dfs::fileFetchContents( '$filePath' )" );
        $contents = self::$dbbackend->_fetchContents( $filePath );
        return $contents;
    }
774922
final public function getObjectsList($objectType, $properties = array(), $objectURI = NULL, $objectId = NULL)
    {

        if (empty($properties)):
            if (!empty($this->propertyModel))
                $properties = array_keys($this->propertyModel);
        endif;

        $query = static::getObjectQuery($properties, "?{$this->valueGroup}property_values", NULL, $objectType, $objectURI, $objectId);

        //echo($this->withConditions) ;
        $query .= "\nGROUP BY o.object_id";
        $query .= $this->getListLookUpConditionsClause();
        $query .= $this->getListOrderByStatement();
        $query .= $this->getLimitClause();

        $total = $this->getObjectsListCount($objectType, $properties, $objectURI, $objectId); //Count first
        $results = $this->database->prepare($query)->execute();
        //Could use SQL_CALC_FOUND here but just the same as just using a second query really;
        //$queries = $this->database->getQueryLog();
        $this->resetListLookUpConditions();
        $this->setListTotal($total);

        return $results;
    }
1036829
public function typeCorrectedFetchAll()
    {
        if ($this->columnMeta === null) {
            $columnCount = $this->statement->columnCount();
            $this->columnMeta = [];
            for ($i = 0; $i<$columnCount; $i++) {
                $this->columnMeta[$i] = $this->statement->getColumnMeta($i);
            }
        }

        // Re-map fetched data using columnMeta
        return array_map(
            function ($rowArray) {
                $row = [];
                foreach ($this->columnMeta as $i => $meta) {
                    // Coerce any column types that aren't correctly retrieved from the database
                    if (isset($meta['native_type']) && isset(self::$type_mapping[$meta['native_type']])) {
                        settype($rowArray[$i], self::$type_mapping[$meta['native_type']]);
                    }
                    $row[$meta['name']] = $rowArray[$i];
                }
                return $row;
            },
            $this->statement->fetchAll(PDO::FETCH_NUM)
        );
    }
1356706
@Override
    public void fetch(int numExamples) {
        initializeCurrFromList(data.get(ArrayUtil.range(cursor, cursor + numExamples)).asList());

    }
1155197
public function fetchAll($fetchType = 'assoc')
    {
        if ($fetchType === 'num') {
            return $this->statement->fetchAll(\PDO::FETCH_NUM);
        } elseif ($fetchType === 'assoc') {
            return $this->statement->fetchAll(\PDO::FETCH_ASSOC);
        } elseif ($fetchType === 'obj') {
            return $this->statement->fetchAll(\PDO::FETCH_OBJ);
        }
    }